@arrai-innovations/reactive-helpers 18.0.0 → 18.0.2

package/types/use/search.d.ts

@@ -0,0 +1,144 @@
+/**
+ * A reactive object for passing document options or search options to useSearch.
+ *
+ * @typedef {object} SearchProps
+ * @property {DocumentOptions} customDocumentOptions - FlexSearch.Document options.
+ * @property {SearchOptions} customSearchOptions - Search options.
+ * @property {string} pkKey - The primary key field.
+ */
+/**
+ * A reactive wrapper around FlexSearch.Index.
+ *
+ * @param {object} options - Options.
+ * @param {SearchProps} options.props - Props.
+ * @param {number} [options.throttle] - Throttle wait time.
+ * @returns {SearchInstance} - The instance.
+ */
+export function useSearch({ props, throttle }: {
+    props: SearchProps;
+    throttle?: number;
+}): SearchInstance;
+/**
+ * A reactive object for passing document options or search options to useSearch.
+ */
+export type SearchProps = {
+    /**
+     * - FlexSearch.Document options.
+     */
+    customDocumentOptions: DocumentOptions;
+    /**
+     * - Search options.
+     */
+    customSearchOptions: SearchOptions;
+    /**
+     * - The primary key field.
+     */
+    pkKey: string;
+};
+/**
+ * FlexSearch.Document search options.
+ */
+export type SearchOptions = {
+    /**
+     * - Limit of results.
+     */
+    limit: number;
+};
+/**
+ * Configuration options for creating a document in FlexSearch.
+ */
+export type DocumentOptions = {
+    /**
+     * - The document field to use as an identifier. Populated from `pkKey`.
+     */
+    id: string;
+    /**
+     * - The document field to use as a tag. Default is false, can be set to a string.
+     */
+    tag: boolean | string;
+    /**
+     * - Fields to index. Can be a single string, an array of strings, or an array of objects specifying custom index options.
+     */
+    index: string | string[] | object[];
+    /**
+     * - Specifies if and what document fields to store. Can be false, a string, or an array of strings. Default is false.
+     */
+    store: boolean | string | string[];
+    /**
+     * - Specifies the tokenizer to use.
+     */
+    tokenizer?: string;
+    /**
+     * - Minimum length of a token to be indexed.
+     */
+    minLength?: number;
+};
+export type SearchRawState = {
+    /**
+     * - The search string.
+     */
+    search: string;
+    /**
+     * - The results, where the keys are the ids of the objects that match, and the values are true.
+     */
+    results: object;
+    /**
+     * - Whether the search has been performed.
+     */
+    searched: boolean;
+    /**
+     * - Whether the search is currently running.
+     */
+    searching: boolean;
+    /**
+     * - FlexSearch.Document options.
+     */
+    customDocumentOptions: DocumentOptions;
+    /**
+     * - Search options.
+     */
+    customSearchOptions: SearchOptions;
+    /**
+     * - The number of times the search has been called.
+     */
+    called: number;
+    /**
+     * - The number of times the search has been called, but has not yet returned.
+     */
+    pending: number;
+    /**
+     * - Whether the search is currently running or has pending calls.
+     */
+    running: boolean;
+};
+export type SearchInstance = {
+    /**
+     * - The state.
+     */
+    state: import("vue").UnwrapNestedRefs<SearchRawState>;
+    /**
+     * - Add an index.
+     */
+    addIndex: Function;
+    /**
+     * - Update an index.
+     */
+    updateIndex: Function;
+    /**
+     * - Remove an index.
+     */
+    removeIndex: Function;
+    /**
+     * - Clear the index.
+     */
+    clearIndex: Function;
+    /**
+     * - An event target.
+     */
+    events: EventTarget;
+    /**
+     * - A Vue effect scope.
+     */
+    effectScope: object;
+};
+//# sourceMappingURL=search.d.ts.map

package/types/use/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../use/search.js"],"names":[],"mappings":"AAkEA;;;;;;;GAOG;AAEH;;;;;;;GAOG;AACH,+CAJG;IAA6B,KAAK,EAA1B,WAAW;IACM,QAAQ,GAAzB,MAAM;CACd,GAAU,cAAc,CA0I1B;;;;;;;;2BArJa,eAAe;;;;yBACf,aAAa;;;;WACb,MAAM;;;;;;;;;WApDN,MAAM;;;;;;;;;QAON,MAAM;;;;SACN,OAAO,GAAC,MAAM;;;;WACd,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE;;;;WAC5B,OAAO,GAAC,MAAM,GAAC,MAAM,EAAE;;;;gBACvB,MAAM;;;;gBACN,MAAM;;;;;;YAKN,MAAM;;;;aACN,MAAM;;;;cACN,OAAO;;;;eACP,OAAO;;;;2BACP,eAAe;;;;yBACf,aAAa;;;;YACb,MAAM;;;;aACN,MAAM;;;;aACN,OAAO;;;;;;WAKP,OAAO,KAAK,EAAE,gBAAgB,CAAC,cAAc,CAAC;;;;;;;;;;;;;;;;;;;;YAK9C,WAAW;;;;iBACX,MAAM"}

package/types/use/watchesRunning.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Vue Composition API composable function for watches running.
+ *
+ * @module use/watchesRunning.js
+ */
+/**
+ * The state for watches running.
+ *
+ * @typedef {object} WatchesRunningRawState
+ * @property {import('vue').ComputedRef<boolean>} running - Whether the watches are running.
+ */
+/**
+ * The state for watches running.
+ *
+ * @typedef {import('vue').UnwrapNestedRefs<WatchesRunningRawState>} WatchesRunningState
+ */
+/**
+ * An instance of `useWatchesRunning`.
+ *
+ * @typedef {object} WatchesRunning
+ * @property {WatchesRunningState} state - The state for watches running.
+ * @property {import('vue').EffectScope} effectScope - The effect scope for watches running.
+ */
+/**
+ * A composable function for handling watches running. When all the trigger refs are true,
+ *  the watch sentinel refs are set to true.
+ *
+ * @param {object} options - The options for the watches running.
+ * @param {import('vue').WatchSource[]} options.triggerRefs - The trigger refs.
+ * @param {import('vue').Ref<boolean>[]} options.watchSentinelRefs - The watch sentinel refs.
+ * @returns {WatchesRunning} - The watches running.
+ */
+export function useWatchesRunning({ triggerRefs, watchSentinelRefs }: {
+    triggerRefs: import("vue").WatchSource[];
+    watchSentinelRefs: import("vue").Ref<boolean>[];
+}): WatchesRunning;
+/**
+ * The state for watches running.
+ */
+export type WatchesRunningRawState = {
+    /**
+     * - Whether the watches are running.
+     */
+    running: import("vue").ComputedRef<boolean>;
+};
+/**
+ * The state for watches running.
+ */
+export type WatchesRunningState = import("vue").UnwrapNestedRefs<WatchesRunningRawState>;
+/**
+ * An instance of `useWatchesRunning`.
+ */
+export type WatchesRunning = {
+    /**
+     * - The state for watches running.
+     */
+    state: WatchesRunningState;
+    /**
+     * - The effect scope for watches running.
+     */
+    effectScope: import("vue").EffectScope;
+};
+//# sourceMappingURL=watchesRunning.d.ts.map

package/types/use/watchesRunning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchesRunning.d.ts","sourceRoot":"","sources":["../../use/watchesRunning.js"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;;;;;;GAQG;AACH,sEAJG;IAA6C,WAAW,EAAhD,OAAO,KAAK,EAAE,WAAW,EAAE;IACW,iBAAiB,EAAvD,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,EAAE;CACpC,GAAU,cAAc,CA+B1B;;;;;;;;aAvDa,OAAO,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC;;;;;kCAMnC,OAAO,KAAK,EAAE,gBAAgB,CAAC,sBAAsB,CAAC;;;;;;;;WAOrD,mBAAmB;;;;iBACnB,OAAO,KAAK,EAAE,WAAW"}

package/types/utils/assignReactiveObject.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Adds to a target the missing keys from a source. `addedKeys` can be precalculated to avoid recalculation.
+ *
+ * @param {ValidTargetOrSource} target - The object receiving values.
+ * @param {ValidTargetOrSource} source - The object providing values.
+ * @param {Array} [exclude] - Keys to exclude from the addition.
+ * @param {Array|Set} [addedKeys] - Precaulcated array of keys to add, if available. Otherwise, the
+ * keys will be calculated.
+ * @returns {boolean} True if any keys were added, false otherwise.
+ * @throws {AssignReactiveObjectError} If either target or source are not ultimately objects or arrays.
+ */
+export function addReactiveObject(target: ValidTargetOrSource, source: ValidTargetOrSource, exclude?: any[], addedKeys?: any[] | Set<any>): boolean;
+/**
+ * Updates a target with mutually shared keys from a source. `sameKeys` can be precalculated to avoid recalculation.
+ *
+ * @param {ValidTargetOrSource} target - The object receiving values.
+ * @param {ValidTargetOrSource} source - The object providing values.
+ * @param {Array} [exclude] - Keys to exclude from the update.
+ * @param {Array|Set} [sameKeys] - Precaulcated array of keys to update, if available. Otherwise, the
+ * keys will be calculated.
+ * @returns {boolean} True if any keys were updated, false otherwise.
+ * @throws {AssignReactiveObjectError} If either target or source are not ultimately objects or arrays.
+ */
+export function updateReactiveObject(target: ValidTargetOrSource, source: ValidTargetOrSource, exclude?: any[], sameKeys?: any[] | Set<any>): boolean;
+/**
+ * Adds to a target the missing keys from a source, and updates a target with mutually shared keys from a source.
+ *
+ * @param {ValidTargetOrSource} target - The object receiving values.
+ * @param {ValidTargetOrSource} source - The object providing values.
+ * @param {Array} [exclude] - Keys to exclude from the addition or update.
+ * @param {Array|Set} [addedKeys] - Precaulcated array of keys to add, if available. Otherwise, the
+ * keys will be calculated.
+ * @param {Array|Set} [sameKeys] - Precaulcated array of keys to update, if available. Otherwise, the
+ * keys will be calculated.
+ * @param {boolean} [doNotSetUndefinedKeys=true] - If true, do not update keys in the target that are undefined in the source.
+ * @returns {boolean} True if any keys were added or updated, false otherwise.
+ */
+export function addOrUpdateReactiveObject(target: ValidTargetOrSource, source: ValidTargetOrSource, exclude?: any[], addedKeys?: any[] | Set<any>, sameKeys?: any[] | Set<any>, doNotSetUndefinedKeys?: boolean): boolean;
+/**
+ * Removes keys from a target that are not present in a source.
+ *
+ * @param {ValidTargetOrSource} target - The object receiving trimming.
+ * @param {ValidTargetOrSource|null} source - The object that provides the allowed set of keys for calculating `removedKeys`.
+ * @param {Array} [exclude] - Keys to exclude from removal.
+ * @param {Array|Set} [removedKeys] - An array to store removed keys.
+ * @returns {boolean} True if any keys were removed, false otherwise.
+ * @throws {AssignReactiveObjectError} If either target or source are not ultimately objects or arrays.
+ */
+export function trimReactiveObject(target: ValidTargetOrSource, source: ValidTargetOrSource | null, exclude?: any[], removedKeys?: any[] | Set<any>): boolean;
+/**
+ * Change a target to match a source, where keys missing from the source are removed from the target,
+ * keys present in the source are added to the target, and keys present in both are updated in the target.
+ * This function is optimized for arrays.
+ *
+ * @param {ValidTargetOrSource} target - The array receiving updates.
+ * @param {ValidTargetOrSource} source - The reactive array to assign.
+ * @returns {boolean} True if any keys were added, updated, or removed, false otherwise.
+ */
+export function assignReactiveArray(target: ValidTargetOrSource, source: ValidTargetOrSource): boolean;
+/**
+ * Change a target to match a source, where keys missing from the source are removed from the target,
+ * keys present in the source are added to the target, and keys present in both are updated in the target.
+ *
+ * @param {ValidTargetOrSource} target - The target object or array.
+ * @param {ValidTargetOrSource} source - The reactive object to assign.
+ * @param {Array} [exclude] - Keys to exclude from the assignment.
+ * @throws {AssignReactiveObjectError} If either target or source are not ultimately objects or arrays.
+ * @returns {boolean} True if any keys were added, updated, or removed, false otherwise.
+ */
+export function assignReactiveObject(target: ValidTargetOrSource, source: ValidTargetOrSource, exclude?: any[]): boolean;
+/**
+ * Recursively change a target to match a source, where keys missing from the source are removed from the target,
+ * keys present in the source are added to the target, and keys present in both are updated in the target.
+ *
+ * @param {ValidTargetOrSource} target - The object receiving updates.
+ * @param {ValidTargetOrSource} source - The object providing updates.
+ * @param {Array} [exclude] - Keys to exclude from the assignment.
+ * @returns {boolean} True if any keys were added, updated, or removed, false otherwise.
+ * @throws {AssignReactiveObjectError} If either target or source are not ultimately objects or arrays.
+ */
+export function assignReactiveObjectDeep(target: ValidTargetOrSource, source: ValidTargetOrSource, exclude?: any[]): boolean;
+/**
+ * Recursively change a target to match a source, where keys present in the source are added to the target, and
+ * keys present in both are updated in the target. Missing keys are not removed.
+ *
+ * @param {ValidTargetOrSource} target - The object receiving updates.
+ * @param {ValidTargetOrSource} source - The object providing updates.
+ * @param {Array} [exclude] - Keys to exclude from the update.
+ * @returns {boolean} True if any keys were added or updated, false otherwise.
+ * @throws {AssignReactiveObjectError} If either target or source are not ultimately objects or arrays.
+ */
+export function addOrUpdateReactiveObjectDeep(target: ValidTargetOrSource, source: ValidTargetOrSource, exclude?: any[]): boolean;
+/**
+ * Reactive object assignment utilities.
+ *
+ * @module utils/assignReactiveObject.js
+ */
+/**
+ * Error thrown when an invalid value is passed to a function.
+ */
+export class AssignReactiveObjectError extends Error {
+    /**
+     * @param {string} message - The error message.
+     * @param {string} code - The error code.
+     */
+    constructor(message: string, code: string);
+    code: string;
+}
+/**
+ * targets and sources must be refs, objects, or arrays
+ * and refs must ultimately resolve to objects or arrays
+ */
+export type ValidTargetOrSource = import("vue").Ref<object | any[]> | object | any[];
+export type validateTargetAndSourceResult = object;
+//# sourceMappingURL=assignReactiveObject.d.ts.map

package/types/utils/assignReactiveObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assignReactiveObject.d.ts","sourceRoot":"","sources":["../../utils/assignReactiveObject.js"],"names":[],"mappings":"AAiIA;;;;;;;;;;GAUG;AACH,0CARW,mBAAmB,UACnB,mBAAmB,+BAEnB,gBAAS,GAEP,OAAO,CAYnB;AAED;;;;;;;;;;GAUG;AACH,6CARW,mBAAmB,UACnB,mBAAmB,8BAEnB,gBAAS,GAEP,OAAO,CAYnB;AAED;;;;;;;;;;;;GAYG;AACH,kDAVW,mBAAmB,UACnB,mBAAmB,+BAEnB,gBAAS,aAET,gBAAS,0BAET,OAAO,GACL,OAAO,CAoCnB;AAED;;;;;;;;;GASG;AACH,2CAPW,mBAAmB,UACnB,mBAAmB,GAAC,IAAI,iCAExB,gBAAS,GACP,OAAO,CA8BnB;AAsBD;;;;;;;;GAQG;AACH,4CAJW,mBAAmB,UACnB,mBAAmB,GACjB,OAAO,CAmBnB;AAED;;;;;;;;;GASG;AACH,6CANW,mBAAmB,UACnB,mBAAmB,oBAGjB,OAAO,CAiBnB;AAmFD;;;;;;;;;GASG;AACH,iDANW,mBAAmB,UACnB,mBAAmB,oBAEjB,OAAO,CAUnB;AAoBD;;;;;;;;;GASG;AACH,sDANW,mBAAmB,UACnB,mBAAmB,oBAEjB,OAAO,CAUnB;AA9cD;;;;GAIG;AAEH;;GAEG;AACH;IACI;;;OAGG;IACH,qBAHW,MAAM,QACN,MAAM,EAMhB;IADG,aAAgB;CAEvB;;;;;kCAGY,OAAO,KAAK,EAAE,GAAG,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC,GAAG,MAAM,GAAG,GAAG,EAAE;4CAsBlD,MAAM"}

package/types/utils/classes.d.ts

@@ -0,0 +1,22 @@
+export function objectifyClasses(...classes: (CombinedClassesArgument | CombinedClassesArgument[])[]): {
+    [key: string]: boolean;
+};
+export function combineClasses(...classes: (CombinedClassesArgument | CombinedClassesArgument[])[]): CombinedClasses;
+export function stringifyClasses(...classes: (CombinedClassesArgument | CombinedClassesArgument[])[]): string;
+export function stringifyClass(cls: ((CombinedClassesArgument | CombinedClassesArgument[]) | null | undefined)[]): string | null | undefined;
+/**
+ * - The normalized form of the CSS classes, either as a string of space-separated class names or an
+ */
+export type CombinedClasses = (string | {
+    [classnames: string]: boolean | import("vue").Ref<boolean>;
+} | {
+    [classnames: string]: boolean | import("vue").Ref<boolean>;
+}[]);
+export type NestedArrayStructureWithStrings = (string | string[] | import("vue").Ref<string | string[]>);
+export type BooleanOrRef = boolean | import("vue").Ref<boolean>;
+export type CombinedClassesArgument = (NestedArrayStructureWithStrings | {
+    [key: string]: BooleanOrRef | NestedArrayStructureWithStrings | CombinedClassesArgument;
+} | import("vue").Ref<NestedArrayStructureWithStrings | {
+    [key: string]: BooleanOrRef | NestedArrayStructureWithStrings | CombinedClassesArgument;
+}>);
+//# sourceMappingURL=classes.d.ts.map

package/types/utils/classes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classes.d.ts","sourceRoot":"","sources":["../../utils/classes.js"],"names":[],"mappings":"AAsFO,6CAHO,CAAC,uBAAuB,GAAC,uBAAuB,EAAE,CAAC,EAAA,GACpD;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAC,CA2BpC;AAYM,2CAHO,CAAC,uBAAuB,GAAC,uBAAuB,EAAE,CAAC,EAAA,GACpD,eAAe,CAa3B;AAWM,6CAHO,CAAC,uBAAuB,GAAC,uBAAuB,EAAE,CAAC,EAAA,GACpD,MAAM,CAMD;AAWX,oCAHI,CAAG,CAAC,uBAAuB,GAAC,uBAAuB,EAAE,CAAC,GAAC,IAAI,GAAC,SAAS,GAAA,GACnE,MAAM,GAAC,IAAI,GAAC,SAAS,CA6BjC;;;;8BA/KY,CACZ,MAAY,GACZ;IAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;CAAE,GACpE;IAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,CACnE;8CAIS,CACZ,MAAW,GAAG,MAAM,EAAE,GACtB,OAAY,KAAK,EAAE,GAAG,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,CACtC;2BAIU,OAAO,GAAG,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC;sCAIrC,CACN,+BAA+B,GACrC;IACA,CAAW,GAAG,EAAE,MAAM,GAAG,YAAY,GAC3B,+BAA+B,GAC/B,uBAAuB,CAAA;CAC1B,GACP,OAAa,KAAK,EAAE,GAAG,CAAC,+BAA+B,GAAG;IAC1D,CAAW,GAAG,EAAE,MAAM,GAAG,YAAY,GAC3B,+BAA+B,GAC/B,uBAAuB,CAAA;CAC1B,CAAC,CACL"}

package/types/utils/compact.d.ts

@@ -0,0 +1,4 @@
+export function removeEmptyObjects(obj: object | any[]): void;
+export function compactSparseArrays(obj: object | any[]): void;
+export function removeEmptyObjectsAndCompactSparseArrays(obj: object | any[]): void;
+//# sourceMappingURL=compact.d.ts.map

package/types/utils/compact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../../utils/compact.js"],"names":[],"mappings":"AAqCO,wCAHI,MAAM,QAAM,GACV,IAAI,CAIhB;AAkCM,yCAFI,MAAM,QAAQ,QAIxB;AAwCM,8DAHI,MAAM,QAAQ,GACZ,IAAI,CAIhB"}

package/types/utils/deleteKey.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Split a string into an array of keys.
+ *
+ * @param {string} string - The string to split.
+ * @param {object} object - The object to split keys for.
+ * @returns {string[]} Returns the new array of split keys.
+ */
+export function lodashLikePathSplit(string: string, object: object): string[];
+/**
+ * Delete a key from an object. Lodash-like delete function, as companion for get/set.
+ *
+ * @param {object} obj - The object to modify.
+ * @param {string} path - The key to delete.
+ */
+export function del(obj: object, path: string): void;
+//# sourceMappingURL=deleteKey.d.ts.map

package/types/utils/deleteKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleteKey.d.ts","sourceRoot":"","sources":["../../utils/deleteKey.js"],"names":[],"mappings":"AAgBA;;;;;;GAMG;AACH,4CAJW,MAAM,UACN,MAAM,GACJ,MAAM,EAAE,CAkBpB;AAED;;;;;GAKG;AACH,yBAHW,MAAM,QACN,MAAM,QAiBhB"}

package/types/utils/flattenPaths.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Get all paths from an array or object.
+ *
+ * @module utils/flattenPaths.js
+ */
+/**
+ * Turn an array or object into an array of path strings. Recurses for any found arrays or objects.
+ *
+ * Array indexes are wrapped in square brackets and object keys are prefixed with a period.
+ *
+ * @param {Array | object} arrayOrObject - Array or object to flatten.
+ * @param {object} [options] - Options.
+ * @param {string} [options.currentPath=""] - Current path, for recursion or as a starting point.
+ * @param {number} [options.depth=0] - Current depth, for recursion.
+ * @param {number} [options.limit=0] - Limit the depth of recursion.
+ * @returns {string[]} Paths.
+ */
+export function flattenPaths(arrayOrObject: any[] | object, { currentPath, depth, limit }?: {
+    currentPath?: string;
+    depth?: number;
+    limit?: number;
+}): string[];
+//# sourceMappingURL=flattenPaths.d.ts.map

package/types/utils/flattenPaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flattenPaths.d.ts","sourceRoot":"","sources":["../../utils/flattenPaths.js"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH;;;;;;;;;;;GAWG;AACH,4CAPW,QAAQ,MAAM,kCAEtB;IAAyB,WAAW,GAA5B,MAAM;IACW,KAAK,GAAtB,MAAM;IACW,KAAK,GAAtB,MAAM;CACd,GAAU,MAAM,EAAE,CAwCpB"}

package/types/utils/getFakePk.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Get a fake pk that is not in the array, set, map, or object. The fake pk is negative number, so they can be
+ * differentiated from real ids. They are returned as strings, as javascript object property keys are always strings.
+ *
+ * @param {Array|Set|Map|object} arraySetMapOrObject - The array, set, map, or object to check for the fake pk.
+ *  An array is assumed to be an array of objects.
+ *  A set is assumed to be a set of ids.
+ *  A map or object is assumed to be an object with keys that are ids.
+ * @param {string} key - The key to check for in the array or object.
+ * @returns {string} - The fake pk.
+ */
+export function getFakePk(arraySetMapOrObject: any[] | Set<any> | Map<any, any> | object, key?: string): string;
+//# sourceMappingURL=getFakePk.d.ts.map

package/types/utils/getFakePk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFakePk.d.ts","sourceRoot":"","sources":["../../utils/getFakePk.js"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,+CAPW,mCAAc,MAAM,QAIpB,MAAM,GACJ,MAAM,CAmBlB"}

package/types/utils/keepAliveTry.d.ts

@@ -0,0 +1,15 @@
+/**
+ * If there is an active component, set up an onActivated hook.
+ *
+ * @param {Function} fn - The function to call.
+ * @param {any} [target] - The target to call the function on.
+ */
+export function tryOnActivated(fn: Function, target?: any): void;
+/**
+ * If there is an active component, set up an onDeactivated hook.
+ *
+ * @param {Function} fn - The function to call.
+ * @param {any} [target] - The target to call the function on.
+ */
+export function tryOnDeactivated(fn: Function, target?: any): void;
+//# sourceMappingURL=keepAliveTry.d.ts.map

package/types/utils/keepAliveTry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keepAliveTry.d.ts","sourceRoot":"","sources":["../../utils/keepAliveTry.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,sDAFW,GAAG,QAOb;AAED;;;;;GAKG;AACH,wDAFW,GAAG,QAOb"}

package/types/utils/keyDiff.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Calculate the difference between objects in terms of what keys
+ * are the same, what keys are removed, and what keys are added.
+ *
+ * @module utils/keyDiff.js
+ */
+/**
+ * Result object of keyDiff and keyDiffDeep.
+ *
+ * @typedef {object} KeyDiffResult
+ * @property {Set} [sameKeys] - If sameKeys option is true, return keys that are the same.
+ * @property {Set} [removedKeys] - If removedKeys option is true, return keys that are removed.
+ * @property {Set} [addedKeys] - If addedKeys option is true, return keys that are added.
+ */
+/**
+ * Calculate the difference between two arrays of keys, in terms of what keys
+ * are the same, what keys are removed, and what keys are added.
+ *
+ * @param {string[]|Set} newKeys - Keys to consider as new.
+ * @param {string[]|Set} oldKeys - Keys to consider as old.
+ * @param {object} [options] - Which differences are returned.
+ * @param {boolean} [options.sameKeys=true] - If true, return keys that are the same.
+ * @param {boolean} [options.removedKeys=true] - If true, return keys that are removed.
+ * @param {boolean} [options.addedKeys=true] - If true, return keys that are added.
+ * @returns {KeyDiffResult} - The differences.
+ */
+export function keyDiff(newKeys: string[] | Set<any>, oldKeys: string[] | Set<any>, { sameKeys, removedKeys, addedKeys }?: {
+    sameKeys?: boolean;
+    removedKeys?: boolean;
+    addedKeys?: boolean;
+}): KeyDiffResult;
+/**
+ * Calculate the difference between two objects, in terms of what keys are the same,
+ * what keys are removed, and what keys are added. Keys are sourced deeply in the objects.
+ *
+ * @param {object} newObj - The new version of the object.
+ * @param {object} oldObj - The old version of the object.
+ * @param {object} [options] - Which differences are returned.
+ * @property {boolean} [sameKeys=true] - If true, return keys that are the same.
+ * @property {boolean} [removedKeys=true] - If true, return keys that are removed.
+ * @property {boolean} [addedKeys=true] - If true, return keys that are added.
+ * @property {number} [limit] - Limit the depth of recursion.
+ * @returns {KeyDiffResult} - The differences.
+ */
+export function keyDiffDeep(newObj: object, oldObj: object, options?: object): KeyDiffResult;
+/**
+ * Result object of keyDiff and keyDiffDeep.
+ */
+export type KeyDiffResult = {
+    /**
+     * - If sameKeys option is true, return keys that are the same.
+     */
+    sameKeys?: Set<any>;
+    /**
+     * - If removedKeys option is true, return keys that are removed.
+     */
+    removedKeys?: Set<any>;
+    /**
+     * - If addedKeys option is true, return keys that are added.
+     */
+    addedKeys?: Set<any>;
+};
+//# sourceMappingURL=keyDiff.d.ts.map

package/types/utils/keyDiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyDiff.d.ts","sourceRoot":"","sources":["../../utils/keyDiff.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;GAWG;AACH,iCARW,MAAM,EAAE,WAAI,WACZ,MAAM,EAAE,WAAI,yCAEpB;IAA0B,QAAQ,GAA1B,OAAO;IACW,WAAW,GAA7B,OAAO;IACW,SAAS,GAA3B,OAAO;CACf,GAAU,aAAa,CAgBzB;AAED;;;;;;;;;;;;GAYG;AACH,oCATW,MAAM,UACN,MAAM,YACN,MAAM,GAKJ,aAAa,CAUzB"}

package/types/utils/loadingCombine.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Combine multiple loading states into a single loading state. If any are loading, the combined state is loading.
+ * If all are undefined, the combined state is undefined. Otherwise, the combined state is not loading.
+ *
+ * @param  {...(boolean | undefined)} loadingStates -  The loading states to combine.
+ * @returns {boolean | undefined} The combined loading state.
+ */
+export function loadingCombine(...loadingStates: (boolean | undefined)[]): boolean | undefined;
+//# sourceMappingURL=loadingCombine.d.ts.map

package/types/utils/loadingCombine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadingCombine.d.ts","sourceRoot":"","sources":["../../utils/loadingCombine.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,iDAHe,CAAC,OAAO,GAAG,SAAS,CAAC,EAAA,GACvB,OAAO,GAAG,SAAS,CAU/B"}

package/types/utils/proxyRunning.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Proxy a parent's running state to a child's running state.
+ *
+ * @param {import("vue").UnwrapNestedRefs<object>} parentState - The parent state.
+ * @param {string} parentStateProp - The parent state property.
+ * @param {import("vue").Ref<boolean>} ref - The ref to proxy to.
+ */
+export function proxyRunning(parentState: import("vue").UnwrapNestedRefs<object>, parentStateProp: string, ref: import("vue").Ref<boolean>): void;
+//# sourceMappingURL=proxyRunning.d.ts.map

package/types/utils/proxyRunning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxyRunning.d.ts","sourceRoot":"","sources":["../../utils/proxyRunning.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,0CAJW,OAAO,KAAK,EAAE,gBAAgB,CAAC,MAAM,CAAC,mBACtC,MAAM,OACN,OAAO,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,QA0BpC"}

package/types/utils/relatedCalculatedHelpers.d.ts

@@ -0,0 +1,5 @@
+export const relatedItemRegex: RegExp;
+export const calculatedItemRegex: RegExp;
+export function getObjectRelatedCalculatedByKey(obj: object, relatedObj: object, calculatedObj: object, key: string): [object, string];
+export function getObjectRelatedByKey(obj: object, relatedObj: object, key: string): [object, string];
+//# sourceMappingURL=relatedCalculatedHelpers.d.ts.map

package/types/utils/relatedCalculatedHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relatedCalculatedHelpers.d.ts","sourceRoot":"","sources":["../../utils/relatedCalculatedHelpers.js"],"names":[],"mappings":"AAAA,sCAAiD;AACjD,yCAAuD;AAWhD,qDANI,MAAM,cACN,MAAM,iBACN,MAAM,OACN,MAAM,GACJ,CAAC,MAAM,EAAE,MAAM,CAAC,CAe5B;AAUM,2CALI,MAAM,cACN,MAAM,OACN,MAAM,GACJ,CAAC,MAAM,EAAE,MAAM,CAAC,CAS5B"}

package/types/utils/set.d.ts

@@ -0,0 +1,7 @@
+export function isSuperset(set: Set<any>, subset: Set<any>): boolean;
+export function union(setA: Set<any>, setB: Set<any>): Set<any>;
+export function intersection(setA: Set<any>, setB: Set<any>): Set<any>;
+export function symmetricDifference(setA: Set<any>, setB: Set<any>): Set<any>;
+export function difference(setA: Set<any>, setB: Set<any>): Set<any>;
+export function equals(setA: Set<any>, setB: Set<any>): boolean;
+//# sourceMappingURL=set.d.ts.map

package/types/utils/set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../utils/set.js"],"names":[],"mappings":"AAaO,6DANM,OAAO,CAanB;AAaM,gEAMN;AAaM,uEAQN;AAaM,8EAUN;AAaM,qEAMN;AAaM,wDANM,OAAO,CAQnB"}

package/types/utils/transformWalk.d.ts

@@ -0,0 +1,2 @@
+export function transformWalk(obj: object, transformFn: Function, path?: string): object;
+//# sourceMappingURL=transformWalk.d.ts.map

package/types/utils/transformWalk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformWalk.d.ts","sourceRoot":"","sources":["../../utils/transformWalk.js"],"names":[],"mappings":"AAwCO,mCA5BI,MAAM,gCAEN,MAAM,GACJ,MAAM,CAyClB"}