type Tail = ((...t: T) => any) extends ( _: any, ...tail: infer TT ) => any ? TT : [] type PrimitiveType = number | string | boolean /** Object types that should never be mapped */ type AtomicObject = | Function | WeakMap | WeakSet | Promise | Date | RegExp export type Draft = T extends PrimitiveType ? T : T extends AtomicObject ? T : T extends Map ? DraftMap : T extends Set ? DraftSet : T extends object ? {-readonly [K in keyof T]: Draft} : T // Inline these in ts 3.7 interface DraftMap extends Map, Draft> {} // Inline these in ts 3.7 interface DraftSet extends Set> {} /** Convert a mutable type into a readonly type */ export type Immutable = T extends PrimitiveType ? T : T extends AtomicObject ? T : T extends Map // Ideally, but wait for TS 3.7: ? Omit, "set" | "delete" | "clear"> ? ImmutableMap : T extends Set // Ideally, but wait for TS 3.7: ? Omit, "add" | "delete" | "clear"> ? ImmutableSet : T extends object ? {readonly [K in keyof T]: Immutable} : T interface ImmutableMap extends Map, Immutable> {} interface ImmutableSet extends Set> {} export interface Patch { op: "replace" | "remove" | "add" path: (string | number)[] value?: any } export type PatchListener = (patches: Patch[], inversePatches: Patch[]) => void /** Converts `nothing` into `undefined` */ type FromNothing = T extends Nothing ? undefined : T /** The inferred return type of `produce` */ export type Produced = Return extends void ? Base : Return extends Promise ? Promise> : FromNothing /** * The `produce` function takes a value and a "recipe function" (whose * return value often depends on the base state). The recipe function is * free to mutate its first argument however it wants. All mutations are * only ever applied to a __copy__ of the base state. * * Pass only a function to create a "curried producer" which relieves you * from passing the recipe function every time. * * Only plain objects and arrays are made mutable. All other objects are * considered uncopyable. * * Note: This function is __bound__ to its `Immer` instance. * * @param {any} base - the initial state * @param {Function} producer - function that receives a proxy of the base state as first argument and which can be freely modified * @param {Function} patchListener - optional function that will be called with all the patches produced here * @returns {any} a new state, or the initial state if nothing was modified */ export interface IProduce { /** Curried producer */ < Recipe extends (...args: any[]) => any, Params extends any[] = Parameters, T = Params[0] >( recipe: Recipe ): >( base: Base, ...rest: Tail ) => Produced> // ^ by making the returned type generic, the actual type of the passed in object is preferred // over the type used in the recipe. However, it does have to satisfy the immutable version used in the recipe // Note: the type of S is the widened version of T, so it can have more props than T, but that is technically actually correct! /** Curried producer with initial state */ < Recipe extends (...args: any[]) => any, Params extends any[] = Parameters, T = Params[0] >( recipe: Recipe, initialState: Immutable ): >( base?: Base, ...rest: Tail ) => Produced> /** Normal producer */ , Return = void>( base: Base, recipe: (draft: D) => Return, listener?: PatchListener ): Produced } export const produce: IProduce export default produce /** * Like `produce`, but instead of just returning the new state, * a tuple is returned with [nextState, patches, inversePatches] * * Like produce, this function supports currying */ export interface IProduceWithPatches { /** Curried producer */ < Recipe extends (...args: any[]) => any, Params extends any[] = Parameters, T = Params[0] >( recipe: Recipe ): >( base: Base, ...rest: Tail ) => [Produced>, Patch[], Patch[]] // ^ by making the returned type generic, the actual type of the passed in object is preferred // over the type used in the recipe. However, it does have to satisfy the immutable version used in the recipe // Note: the type of S is the widened version of T, so it can have more props than T, but that is technically actually correct! /** Curried producer with initial state */ < Recipe extends (...args: any[]) => any, Params extends any[] = Parameters, T = Params[0] >( recipe: Recipe, initialState: Immutable ): >( base?: Base, ...rest: Tail ) => [Produced>, Patch[], Patch[]] /** Normal producer */ , Return = void>( base: Base, recipe: (draft: D) => Return ): [Produced, Patch[], Patch[]] } export const produceWithPatches: IProduceWithPatches /** Use a class type for `nothing` so its type is unique */ declare class Nothing { // This lets us do `Exclude` private _: any } /** * The sentinel value returned by producers to replace the draft with undefined. */ export const nothing: Nothing /** * To let Immer treat your class instances as plain immutable objects * (albeit with a custom prototype), you must define either an instance property * or a static property on each of your custom classes. * * Otherwise, your class instance will never be drafted, which means it won't be * safe to mutate in a produce callback. */ export const immerable: unique symbol /** * Pass true to automatically freeze all copies created by Immer. * * By default, auto-freezing is disabled in production. */ export function setAutoFreeze(autoFreeze: boolean): void /** * Pass true to use the ES2015 `Proxy` class when creating drafts, which is * always faster than using ES5 proxies. * * By default, feature detection is used, so calling this is rarely necessary. */ export function setUseProxies(useProxies: boolean): void /** * Apply an array of Immer patches to the first argument. * * This function is a producer, which means copy-on-write is in effect. */ export function applyPatches(base: S, patches: Patch[]): S /** * Create an Immer draft from the given base state, which may be a draft itself. * The draft can be modified until you finalize it with the `finishDraft` function. */ export function createDraft(base: T): Draft /** * Finalize an Immer draft from a `createDraft` call, returning the base state * (if no changes were made) or a modified copy. The draft must *not* be * mutated afterwards. * * Pass a function as the 2nd argument to generate Immer patches based on the * changes that were made. */ export function finishDraft(draft: T, listener?: PatchListener): Immutable /** Get the underlying object that is represented by the given draft */ export function original(value: T): T | void /** Takes a snapshot of the current state of a draft and finalizes it (but without freezing). This is a great utility to print the current state during debugging (no Proxies in the way). The output of current can also be safely leaked outside the producer. */ export function current(value: T): T /** Returns true if the given value is an Immer draft */ export function isDraft(value: any): boolean /** Returns true if the given value can be drafted by Immer */ export function isDraftable(value: any): boolean export class Immer { constructor(config: { useProxies?: boolean autoFreeze?: boolean onAssign?: ( state: ImmerState, prop: string | number, value: unknown ) => void onDelete?: (state: ImmerState, prop: string | number) => void onCopy?: (state: ImmerState) => void }) /** * The `produce` function takes a value and a "recipe function" (whose * return value often depends on the base state). The recipe function is * free to mutate its first argument however it wants. All mutations are * only ever applied to a __copy__ of the base state. * * Pass only a function to create a "curried producer" which relieves you * from passing the recipe function every time. * * Only plain objects and arrays are made mutable. All other objects are * considered uncopyable. * * Note: This function is __bound__ to its `Immer` instance. * * @param {any} base - the initial state * @param {Function} producer - function that receives a proxy of the base state as first argument and which can be freely modified * @param {Function} patchListener - optional function that will be called with all the patches produced here * @returns {any} a new state, or the initial state if nothing was modified */ produce: IProduce /** * When true, `produce` will freeze the copies it creates. */ readonly autoFreeze: boolean /** * When true, drafts are ES2015 proxies. */ readonly useProxies: boolean /** * Pass true to automatically freeze all copies created by Immer. * * By default, auto-freezing is disabled in production. */ setAutoFreeze(autoFreeze: boolean): void /** * Pass true to use the ES2015 `Proxy` class when creating drafts, which is * always faster than using ES5 proxies. * * By default, feature detection is used, so calling this is rarely necessary. */ setUseProxies(useProxies: boolean): void } export interface ImmerState { parent?: ImmerState base: T copy: T assigned: {[prop: string]: boolean; [index: number]: boolean} } // Backward compatibility with --target es5 declare global { interface Set {} interface Map {} interface WeakSet {} interface WeakMap {} } export declare function enableAllPlugins(): void export declare function enableES5(): void export declare function enableMapSet(): void export declare function enablePatches(): void