@dabble/patches 0.2.9 → 0.2.10

package/dist/event-signal.js

@@ -26,15 +26,15 @@ export function signal() {
     }
     signal.emit = async (...args) => {
         const listeners = args[0] instanceof Error ? errorListeners : subscribers;
-        Array.from(listeners).map(ref => {
+        await Promise.all(Array.from(listeners).map(ref => {
             const listener = ref.deref();
             if (listener) {
-                listener(...args);
+                return listener(...args);
             }
             else {
                 listeners.delete(ref);
             }
-        });
+        }));
     };
     signal.error = (errorListener) => {
         errorListeners.add(new WeakRef(errorListener));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dabble/patches",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "description": "Immutable JSON Patch implementation based on RFC 6902 supporting operational transformation and last-writer-wins",
   "author": "Jacob Wright <jacwright@gmail.com>",
   "bugs": {

package/dist/json-patch/patchProxy.d.ts

@@ -1,41 +0,0 @@
-import { JSONPatch } from './JSONPatch';
-/**
- * Creates a proxy object that can be used in two ways:
- *
- * 1.  **Path Generation:** When used without a `JSONPatch` instance, accessing properties
- *     on the proxy generates a JSON Pointer path string via `toString()`. This allows
- *     for type-safe path creation when using `JSONPatch` methods directly.
- *     ```ts
- *     const patch = new JSONPatch();
- *     const proxy = createPatchProxy<MyType>();
- *     patch.text(proxy.content, new Delta().insert('text')); // Path is '/content'
- *     patch.increment(proxy.counter, 5);                     // Path is '/counter'
- *     ```
- *
- * 2.  **Automatic Patch Generation:** When created with a target object and a `JSONPatch`
- *     instance, modifying the proxy (setting properties, calling array methods like
- *     `push`, `splice`, etc.) automatically generates the corresponding JSON Patch
- *     operations and adds them to the provided `patch` instance.
- *     ```ts
- *     const patch = new JSONPatch();
- *     const myObj = { name: { first: 'Alice' }, tags: ['a'] };
- *     const proxy = createPatchProxy(myObj, patch);
- *     proxy.name.first = 'Bob';  // Generates replace op
- *     proxy.tags.push('b');      // Generates add op
- *     ```
- *
- * The proxy behaves like the original value in most contexts due to the `valueOf` trap.
- * For optional properties, use the non-null assertion operator (!) when setting values:
- * ```ts
- * interface User { middleName?: string }
- * const proxy = createPatchProxy<User>(user, patch);
- * proxy.middleName! = 'John';  // Assert middleName exists before setting
- * ```
- *
- * @template T The type of the object to proxy.
- * @param target The target object (required for automatic patch generation mode).
- * @param patch The `JSONPatch` instance to add generated operations to (required for automatic patch generation mode).
- * @returns A proxy object of type T.
- */
-export declare function createPatchProxy<T>(): T;
-export declare function createPatchProxy<T>(target: T, patch: JSONPatch): T;

package/dist/json-patch/patchProxy.js

@@ -1,125 +0,0 @@
-// We use a function as the target so that `push` and other array methods can be called without error.
-const proxyFodder = {};
-export function createPatchProxy(target, patch) {
-    // Call the internal implementation
-    return createPatchProxyInternal(target, patch);
-}
-// Internal implementation with the path parameter
-function createPatchProxyInternal(target, patch, path = '') {
-    // Always use an empty function as the proxy target
-    // This allows us to proxy any type of value, including primitives and undefined,
-    // and enables calling array methods like push/splice directly on array proxies.
-    return new Proxy(proxyFodder, {
-        get(_, prop) {
-            // Return the value directly for symbol properties (not relevant for JSON paths)
-            if (typeof prop === 'symbol') {
-                return target?.[prop];
-            }
-            // Handle toString specially to make properties work as PathLike
-            if (prop === 'toString') {
-                return function () {
-                    return path;
-                };
-            }
-            // Handle valueOf to make the proxy behave like the original value in most contexts
-            if (prop === 'valueOf') {
-                return function () {
-                    return target;
-                };
-            }
-            // --- Array Method Interception ---
-            if (Array.isArray(target)) {
-                switch (prop) {
-                    case 'push':
-                        return (...items) => {
-                            const index = target.length;
-                            for (let i = 0; i < items.length; i++) {
-                                patch?.add(`${path}/${index + i}`, items[i]);
-                            }
-                        };
-                    case 'pop':
-                        return () => {
-                            const index = target.length - 1;
-                            if (index >= 0) {
-                                patch?.remove(`${path}/${index}`);
-                            }
-                        };
-                    case 'shift':
-                        return () => {
-                            if (target.length > 0) {
-                                patch?.remove(`${path}/0`);
-                            }
-                        };
-                    case 'unshift':
-                        return (...items) => {
-                            for (let i = 0; i < items.length; i++) {
-                                patch?.add(`${path}/${i}`, items[i]);
-                            }
-                        };
-                    case 'splice':
-                        return (start, deleteCount, ...items) => {
-                            const actualStart = start < 0 ? Math.max(target.length + start, 0) : Math.min(start, target.length);
-                            const actualDeleteCount = Math.min(Math.max(deleteCount === undefined ? target.length - actualStart : deleteCount, 0), target.length - actualStart);
-                            // Remove deleted elements
-                            for (let i = 0; i < actualDeleteCount; i++) {
-                                patch?.remove(`${path}/${actualStart}`); // Path automatically adjusts for subsequent removes
-                            }
-                            // Add new elements
-                            for (let i = 0; i < items.length; i++) {
-                                patch?.add(`${path}/${actualStart + i}`, items[i]);
-                            }
-                        };
-                }
-            }
-            // --- End Array Method Interception ---
-            // Create a proxy for the property value if it's not an intercepted array method
-            // This handles objects, primitives, and undefined values uniformly
-            // Call the internal implementation recursively
-            return createPatchProxyInternal(target?.[prop], patch, `${path}/${String(prop)}`);
-        },
-        set(_, prop, value) {
-            // Ignore setting the 'length' property on arrays directly
-            if (Array.isArray(target) && prop === 'length') {
-                return true;
-            }
-            if (target?.[prop] === value)
-                return true;
-            const patchPath = `${path}/${String(prop)}`;
-            if (value === undefined) {
-                patch?.remove(patchPath);
-            }
-            else {
-                patch?.replace(patchPath, value);
-            }
-            return true;
-        },
-        deleteProperty(_, prop) {
-            if (target == null || prop in target) {
-                patch?.remove(`${path}/${String(prop)}`);
-            }
-            return true;
-        },
-        // Make the proxy appear to be the same type as the target
-        getPrototypeOf() {
-            return Object.getPrototypeOf(target);
-        },
-        // Support instanceof checks
-        isExtensible() {
-            return target != null && Object.isExtensible(target);
-        },
-        // Support Object.keys and other enumeration methods
-        ownKeys() {
-            return target != null && typeof target === 'object' ? Reflect.ownKeys(target) : [];
-        },
-        // Support property descriptor access
-        getOwnPropertyDescriptor(_, prop) {
-            if (target == null || typeof target !== 'object')
-                return undefined;
-            return Object.getOwnPropertyDescriptor(target, prop);
-        },
-        // Support Object.hasOwnProperty
-        has(_, prop) {
-            return target != null && typeof target === 'object' && prop in target;
-        },
-    });
-}

package/dist/json-patch/state.d.ts

@@ -1,2 +0,0 @@
-import type { JSONPatchOpHandlerMap, Runner } from './types.js';
-export declare function runWithObject(object: any, allTypes: JSONPatchOpHandlerMap, shouldCache: boolean, callback: Runner): any;

package/dist/json-patch/state.js

@@ -1,8 +0,0 @@
-export function runWithObject(object, allTypes, shouldCache, callback) {
-    const state = {
-        root: { '': object },
-        types: allTypes,
-        cache: shouldCache ? new Set() : null,
-    };
-    return callback(state) || state.root[''];
-}

package/dist/json-patch/transformPatch.d.ts

@@ -1,19 +0,0 @@
-/*!
- * Based on work from
- * https://github.com/Palindrom/JSONPatchOT
- * (c) 2017 Tomek Wytrebowicz
- *
- * MIT license
- * (c) 2022 Jacob Wright
- *
- *
- * WARNING: using /array/- syntax to indicate the end of the array makes it impossible to transform arrays correctly in
- * all situaions. Please avoid using this syntax when using Operational Transformations.
- */
-import type { JSONPatchOp, JSONPatchOpHandlerMap } from './types.js';
-/**
- * Transform an array of JSON Patch operations against another array of JSON Patch operations. Returns a new array with
- * transformed operations. Operations that change are cloned, making the results of this function immutable.
- * `otherOps` are transformed over `thisOps` with thisOps considered to have happened first.
- */
-export declare function transformPatch(obj: any, thisOps: JSONPatchOp[], otherOps: JSONPatchOp[], custom?: JSONPatchOpHandlerMap): JSONPatchOp[];

package/dist/json-patch/transformPatch.js

@@ -1,37 +0,0 @@
-/*!
- * Based on work from
- * https://github.com/Palindrom/JSONPatchOT
- * (c) 2017 Tomek Wytrebowicz
- *
- * MIT license
- * (c) 2022 Jacob Wright
- *
- *
- * WARNING: using /array/- syntax to indicate the end of the array makes it impossible to transform arrays correctly in
- * all situaions. Please avoid using this syntax when using Operational Transformations.
- */
-import { getTypes } from './ops/index.js';
-import { runWithObject } from './state.js';
-import { getType } from './utils/getType.js';
-import { log } from './utils/log.js';
-/**
- * Transform an array of JSON Patch operations against another array of JSON Patch operations. Returns a new array with
- * transformed operations. Operations that change are cloned, making the results of this function immutable.
- * `otherOps` are transformed over `thisOps` with thisOps considered to have happened first.
- */
-export function transformPatch(obj, thisOps, otherOps, custom) {
-    const types = getTypes(custom);
-    return runWithObject(obj, types, false, state => {
-        return thisOps.reduce((otherOps, thisOp) => {
-            // transform ops with patch operation
-            const handler = getType(state, thisOp)?.transform;
-            if (typeof handler === 'function') {
-                otherOps = handler(state, thisOp, otherOps);
-            }
-            else {
-                log('No function to transform against for', thisOp.op);
-            }
-            return otherOps;
-        }, otherOps);
-    });
-}

package/dist/json-patch/types.d.ts

@@ -1,52 +0,0 @@
-export interface JSONPatchOpHandler {
-    like: 'add' | 'remove' | 'replace' | 'move' | 'copy' | 'test';
-    apply(state: State, path: string, valueOrFrom: any): string | void;
-    transform(state: State, other: JSONPatchOp, ops: JSONPatchOp[]): JSONPatchOp[];
-    invert(state: State, op: JSONPatchOp, value: any, changedObj: any, isIndex: boolean): JSONPatchOp;
-    compose?(state: State, value1: any, value2: any): any;
-}
-export interface JSONPatchOpHandlerMap {
-    [key: string]: JSONPatchOpHandler;
-}
-export interface ApplyJSONPatchOptions {
-    /**
-     * Do not reject patches if error occurs (partial patching)
-     */
-    partial?: boolean;
-    /**
-     * Throw an exception if an error occurs when patching
-     */
-    strict?: boolean;
-    /**
-     * Stop on error and return the original object (without throwing an exception)
-     */
-    rigid?: boolean;
-    /**
-     * Don't log errors when they occurs during patching, if strict is not true, errors will be logged if this is false
-     */
-    silent?: boolean;
-    /**
-     * Saves the patch that caused the error to this property of the options object
-     */
-    error?: JSONPatchOp;
-    /**
-     * Apply changes at a given path prefix
-     */
-    atPath?: string;
-}
-export interface JSONPatchOp {
-    op: string;
-    path: string;
-    from?: string;
-    value?: any;
-    soft?: boolean;
-}
-export interface Root {
-    '': any;
-}
-export type State = {
-    root: Root;
-    types: JSONPatchOpHandlerMap;
-    cache: Set<any> | null;
-};
-export type Runner = (state: State) => any;

package/dist/json-patch/types.js

@@ -1 +0,0 @@
-export {};

package/dist/json-patch/utils/deepEqual.d.ts

@@ -1 +0,0 @@
-export declare function deepEqual(a: any, b: any): boolean;

package/dist/json-patch/utils/deepEqual.js

@@ -1,33 +0,0 @@
-export function deepEqual(a, b) {
-    if (a === b) {
-        return true;
-    }
-    if (!(a && b) || typeof a !== 'object' || typeof b !== 'object') {
-        return false;
-    }
-    if (a.length !== b.length) {
-        return false;
-    }
-    if (Array.isArray(a)) {
-        if (!Array.isArray(b)) {
-            return false;
-        }
-        for (let i = 0, imax = a.length; i < imax; i++) {
-            if (!deepEqual(a[i], b[i])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    const aKeys = Object.keys(a);
-    if (aKeys.length !== Object.keys(b).length) {
-        return false;
-    }
-    for (let j = 0, jmax = aKeys.length; j < jmax; j++) {
-        const key = aKeys[j];
-        if (!deepEqual(a[key], b[key])) {
-            return false;
-        }
-    }
-    return true;
-}

package/dist/json-patch/utils/exit.d.ts

@@ -1,2 +0,0 @@
-import type { ApplyJSONPatchOptions, JSONPatchOp, State } from '../types.js';
-export declare function exit(state: State, object: any, patch: JSONPatchOp, opts: ApplyJSONPatchOptions): any;

package/dist/json-patch/utils/exit.js

@@ -1,4 +0,0 @@
-export function exit(state, object, patch, opts) {
-    opts.error = patch;
-    return opts.partial && state.root ? state.root[''] : object;
-}

package/dist/json-patch/utils/get.d.ts

@@ -1,2 +0,0 @@
-import type { State } from '../types.js';
-export declare function get(state: State, path: string): any;

package/dist/json-patch/utils/get.js

@@ -1,6 +0,0 @@
-import { getOpData } from './getOpData.js';
-export function get(state, path) {
-    // eslint-disable-next-line no-unused-vars
-    const [keys, lastKey, target] = getOpData(state, path);
-    return target ? target[lastKey] : undefined;
-}

package/dist/json-patch/utils/getOpData.d.ts

@@ -1,2 +0,0 @@
-import type { State } from '../types.js';
-export declare function getOpData(state: State, path: string, createMissingObjects?: boolean): any[];

package/dist/json-patch/utils/getOpData.js

@@ -1,10 +0,0 @@
-import { EMPTY, pluck } from './pluck.js';
-import { toKeys } from './toKeys.js';
-export function getOpData(state, path, createMissingObjects) {
-    const keys = toKeys(path);
-    const lastKey = keys[keys.length - 1];
-    let target = pluck(state, keys);
-    if (createMissingObjects)
-        target = target || EMPTY;
-    return [keys, lastKey, target];
-}

package/dist/json-patch/utils/getType.d.ts

@@ -1,3 +0,0 @@
-import type { JSONPatchOp, State } from '../types.js';
-export declare function getType(state: State, patch: JSONPatchOp): import("../types.js").JSONPatchOpHandler;
-export declare function getTypeLike(state: State, patch: JSONPatchOp): "replace" | "add" | "remove" | "move" | "copy" | "test";

package/dist/json-patch/utils/getType.js

@@ -1,6 +0,0 @@
-export function getType(state, patch) {
-    return state.types?.[patch.op];
-}
-export function getTypeLike(state, patch) {
-    return state.types?.[patch.op]?.like;
-}

package/dist/json-patch/utils/index.d.ts

@@ -1,14 +0,0 @@
-export * from './deepEqual.js';
-export * from './get.js';
-export * from './getOpData.js';
-export * from './getType.js';
-export * from './log.js';
-export * from './ops.js';
-export * from './paths.js';
-export * from './pluck.js';
-export * from './shallowCopy.js';
-export * from './softWrites.js';
-export * from './toArrayIndex.js';
-export * from './toKeys.js';
-export * from './updateArrayIndexes.js';
-export * from './updateArrayPath.js';

package/dist/json-patch/utils/index.js

@@ -1,14 +0,0 @@
-export * from './deepEqual.js';
-export * from './get.js';
-export * from './getOpData.js';
-export * from './getType.js';
-export * from './log.js';
-export * from './ops.js';
-export * from './paths.js';
-export * from './pluck.js';
-export * from './shallowCopy.js';
-export * from './softWrites.js';
-export * from './toArrayIndex.js';
-export * from './toKeys.js';
-export * from './updateArrayIndexes.js';
-export * from './updateArrayPath.js';

package/dist/json-patch/utils/log.d.ts

@@ -1,2 +0,0 @@
-export declare function verbose(value: boolean): void;
-export declare function log(...rest: any[]): void;

package/dist/json-patch/utils/log.js

@@ -1,7 +0,0 @@
-let displayLogs = false;
-export function verbose(value) {
-    displayLogs = value;
-}
-export function log(...rest) {
-    displayLogs && console.log(...rest);
-}

package/dist/json-patch/utils/ops.d.ts

@@ -1,14 +0,0 @@
-import type { JSONPatchOp, State } from '../types.js';
-/**
- * Check whether this operation is an add operation of some sort (add, copy, move).
- */
-export declare function isAdd(state: State, op: JSONPatchOp, pathName: 'from' | 'path'): boolean;
-/**
- * Transforms an array of ops, returning the original if there is no change, filtering out ops that are dropped.
- */
-export declare function mapAndFilterOps(ops: JSONPatchOp[], iterator: (op: JSONPatchOp, index: number, breakAfter: (keepRest?: boolean) => {}) => JSONPatchOp | JSONPatchOp[] | null): JSONPatchOp[];
-/**
- * Remove operations that apply to a value which was removed.
- */
-export declare function updateRemovedOps(state: State, thisPath: string, otherOps: JSONPatchOp[], isRemove?: boolean, updatableObject?: boolean, opOp?: string, customHandler?: (op: JSONPatchOp) => any): JSONPatchOp[];
-export declare function transformRemove(state: State, thisPath: string, otherOps: JSONPatchOp[], isRemove?: boolean): JSONPatchOp[];

package/dist/json-patch/utils/ops.js

@@ -1,103 +0,0 @@
-import { getTypeLike } from './getType.js';
-import { log } from './log.js';
-import { isArrayPath } from './paths.js';
-import { updateArrayIndexes } from './updateArrayIndexes.js';
-/**
- * Check whether this operation is an add operation of some sort (add, copy, move).
- */
-export function isAdd(state, op, pathName) {
-    const like = getTypeLike(state, op);
-    return (like === 'add' || like === 'copy' || like === 'move') && pathName === 'path';
-}
-/**
- * Transforms an array of ops, returning the original if there is no change, filtering out ops that are dropped.
- */
-export function mapAndFilterOps(ops, iterator) {
-    let changed = false;
-    const mapped = [];
-    let shouldBreak = false;
-    let keepRest;
-    const breakAfter = (keep) => (shouldBreak = true) && (keepRest = keep);
-    for (let i = 0; i < ops.length; i++) {
-        const original = ops[i];
-        // If an op was copied or moved to the same path, it is a no-op and should be removed
-        if (original.from === original.path) {
-            if (!changed)
-                changed = true;
-            continue;
-        }
-        let value = iterator(original, i, breakAfter);
-        if (value && !Array.isArray(value) && value.from === value.path)
-            value = null;
-        if (!changed && value !== original)
-            changed = true;
-        if (Array.isArray(value))
-            mapped.push(...value);
-        else if (value)
-            mapped.push(value);
-        if (shouldBreak) {
-            if (keepRest)
-                mapped.push(...ops.slice(i + 1));
-            break;
-        }
-    }
-    return changed ? mapped : ops;
-}
-/**
- * Remove operations that apply to a value which was removed.
- */
-export function updateRemovedOps(state, thisPath, otherOps, isRemove = false, updatableObject = false, opOp, customHandler) {
-    const softPrefixes = new Set();
-    return mapAndFilterOps(otherOps, (op, index, breakAfter) => {
-        const opLike = getTypeLike(state, op);
-        const canMergeCustom = customHandler && opOp === op.op;
-        if (thisPath === op.path && opLike !== 'remove' && !canMergeCustom && !op.soft) {
-            // Once an operation sets this value again, we can assume the following ops were working on that and not the
-            // old value so they can be kept
-            if (op.op !== 'test') {
-                breakAfter(true); // stop and keep the remaining ops as-is
-            }
-            return op;
-        }
-        const { path, from } = op;
-        if (path === thisPath && canMergeCustom) {
-            const customOp = customHandler(op);
-            if (customOp)
-                return customOp;
-        }
-        if (isRemove && !updatableObject && from === thisPath) {
-            // Because of the check above, moves and copies will only hit here when the "from" field matches
-            if (opLike === 'move') {
-                // We need the rest of the otherOps to be adjusted against this "move"
-                breakAfter();
-                return transformRemove(state, op.path, otherOps.slice(index + 1));
-            }
-            else if (opLike === 'copy') {
-                // We need future ops on the copied object to be removed
-                breakAfter();
-                let rest = transformRemove(state, thisPath, otherOps.slice(index + 1));
-                rest = transformRemove(state, op.path, rest);
-                return rest;
-            }
-        }
-        if (op.soft && path === thisPath) {
-            softPrefixes.add(path);
-            return null;
-        }
-        const samePath = (!updatableObject && path === thisPath) || (!softPrefixes.has(thisPath) && path.startsWith(`${thisPath}/`));
-        const sameFrom = (!updatableObject && from === thisPath) || (!softPrefixes.has(thisPath) && from?.startsWith(`${thisPath}/`));
-        if (samePath || sameFrom) {
-            log('Removing', op);
-            return null;
-        }
-        return op;
-    });
-}
-export function transformRemove(state, thisPath, otherOps, isRemove) {
-    if (isArrayPath(thisPath, state)) {
-        return updateArrayIndexes(state, thisPath, otherOps, -1, isRemove);
-    }
-    else {
-        return updateRemovedOps(state, thisPath, otherOps, isRemove);
-    }
-}

package/dist/json-patch/utils/paths.d.ts

@@ -1,9 +0,0 @@
-import type { State } from '../types.js';
-export declare function getPrefix(path: string): string;
-export declare function getProp(path: string): string;
-export declare function getPrefixAndProp(path: string): [string, string];
-export declare function getPropAfter(path: string, index: number): string;
-export declare function isArrayPath(path: string, state?: State): boolean;
-export declare function getArrayPrefixAndIndex(state: State, path: string, pathLength?: number): [string, number];
-export declare function getArrayIndex(state: State, path: string, pathLength?: number): number;
-export declare function getIndexAndEnd(state: State, path: string | undefined, maxLength: number): number[];

package/dist/json-patch/utils/paths.js

@@ -1,53 +0,0 @@
-import { getOpData } from './getOpData.js';
-const arrayPathExp = /\/(0|[1-9]\d*)$/;
-const EMPTY = [];
-export function getPrefix(path) {
-    const lastSlash = path.lastIndexOf('/');
-    return path.slice(0, lastSlash + 1);
-}
-export function getProp(path) {
-    const lastSlash = path.lastIndexOf('/');
-    return path.slice(lastSlash + 1);
-}
-export function getPrefixAndProp(path) {
-    const prefix = getPrefix(path);
-    return [prefix, path.slice(prefix.length)];
-}
-export function getPropAfter(path, index) {
-    const lastSlash = path.indexOf('/', index);
-    return path.slice(index, lastSlash === -1 ? undefined : lastSlash);
-}
-export function isArrayPath(path, state) {
-    if (!arrayPathExp.test(path))
-        return false;
-    if (!state || !state.root || !state.root[''])
-        return true;
-    // Double-check if this is an array or not
-    const [_, __, target] = getOpData(state, path);
-    return Array.isArray(target) || target == null;
-}
-export function getArrayPrefixAndIndex(state, path, pathLength) {
-    if (pathLength)
-        path = path.slice(0, path.indexOf('/', pathLength));
-    if (!arrayPathExp.test(path))
-        return EMPTY;
-    const [_, __, target] = getOpData(state, path);
-    if (!Array.isArray(target))
-        return EMPTY;
-    const [prefix, indexStr] = getPrefixAndProp(path);
-    const index = parseInt(indexStr);
-    return [prefix, index];
-}
-export function getArrayIndex(state, path, pathLength) {
-    return getArrayPrefixAndIndex(state, path, pathLength)[1];
-}
-export function getIndexAndEnd(state, path, maxLength) {
-    if (!path)
-        return [];
-    const prop = getPropAfter(path, maxLength);
-    const end = maxLength + prop.length;
-    if (!isArrayPath(path.slice(0, end), state))
-        return [];
-    const index = parseInt(prop);
-    return [index, end];
-}

package/dist/json-patch/utils/pluck.d.ts

@@ -1,5 +0,0 @@
-import type { State } from '../types.js';
-export declare const EMPTY: {};
-export declare function pluck(state: State, keys: string[]): any;
-export declare function pluckWithShallowCopy(state: State, keys: string[], createMissingObjects?: boolean): any;
-export declare function getValue(state: State, value: any, addKey?: string, addValue?: any): any;