Index: frontend/node_modules/immer/compat/pre-3.7/dist/immer.d.ts =================================================================== --- frontend/node_modules/immer/compat/pre-3.7/dist/immer.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/immer/compat/pre-3.7/dist/immer.d.ts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,318 @@ +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