{"version":3,"file":"index.umd.cjs","sources":["../src/utils/isStructure.ts","../src/core/metadata.ts","../src/core/traces.ts","../src/utils/isTraced.ts","../src/utils/iterableWeakMap.ts","../src/core/mutationCallback.ts","../src/core/subscribers.ts","../src/types/mutation.ts","../src/utils/disableTracing.ts","../src/utils/withoutAssigning.ts","../src/utils/withoutTracing.ts","../src/applyTrace.ts","../src/deepClone.ts","../src/core/proxy/reflect.ts","../src/core/proxy/getTracedArray.ts","../src/core/proxy/getTracedObject.ts","../src/core/proxy/deepTrace.ts","../src/traceFabric.ts"],"sourcesContent":["import type { JSONObject } from '../types/json';\n\n/**\n * Check if the value is a typeof `object` and not `null`.\n *\n * @param value - value that needs to be checked.\n * @returns `boolean`\n *\n * @example\n * ```typescript\n * console.log(isStructure({ hello: 'world' })); // true\n * console.log(isStructure(['hello', 'world'])); // true\n *\n * console.log(isStructure(1)); // false\n * console.log(isStructure(true)); // false\n * console.log(isStructure('hello')); // false\n * console.log(isStructure(null)); // false\n * console.log(isStructure(undefined)); // false\n * console.log(isStructure(true)); // false\n * ```\n *\n * @see {@link https://traced-fabric.github.io/core/is-value-a-structure/isStructure.html Wiki page.}\n *\n * @since 0.2.0\n */\nexport function isStructure(\n value: T,\n): value is T extends JSONObject ? T : T & JSONObject {\n return typeof value === 'object' && value !== null;\n}\n","import type { JSONStructure } from '../types/json';\nimport type { TTarget } from '../types/mutation';\nimport { isTracedFabric } from '../utils/isTraced';\n\nexport type TTracedValueMetadata = {\n parentRef: JSONStructure;\n key: TTarget;\n};\n\nexport type TWeakTracedValueMetadata = {\n parentRef: WeakRef;\n key: TTarget;\n};\n\nexport const tracedValuesMetadata = new WeakMap();\n\n/**\n * Will return the metadata of the target if it exists,\n * no matter if rootRef and parentRef are garbage collected.\n */\nexport function getMetadata(target: JSONStructure): TWeakTracedValueMetadata | undefined {\n return tracedValuesMetadata.get(target);\n}\n\n/**\n * Will return the metadata of the target if it exists,\n * and if rootRef and parentRef are NOT garbage collected.\n */\nexport function getStrongMetadata(target: JSONStructure): TTracedValueMetadata | undefined {\n const metadata = getMetadata(target);\n if (!metadata) return;\n\n const parentRef = metadata.parentRef.deref();\n if (!parentRef) return;\n\n return { parentRef, key: metadata.key };\n}\n\nexport function setMetadata(target: JSONStructure, metadata: Required): void {\n tracedValuesMetadata.set(target, {\n parentRef: new WeakRef(metadata.parentRef),\n key: metadata.key,\n });\n}\n\nexport function getRootRef(target: JSONStructure): JSONStructure | undefined {\n if (isTracedFabric(target)) return target;\n\n const metadata = getStrongMetadata(target);\n if (!metadata) return undefined;\n\n return getRootRef(metadata.parentRef);\n}\n\nexport function getTargetChain(target: JSONStructure): TTarget[] {\n const metadata = getStrongMetadata(target);\n const parentTargetChain = metadata?.parentRef ? getTargetChain(metadata.parentRef) : [];\n\n return metadata ? [...parentTargetChain, metadata.key] : [];\n}\n","import type { JSONStructure } from '../types/json';\n\nexport const tracedFabricsTrace = new WeakMap();\n","import { tracedValuesMetadata } from '../core/metadata';\nimport { tracedFabricsTrace } from '../core/traces';\n\n/**\n * Checks if the given value is a `tracedFabric`.\n *\n * @example\n * ```typescript\n * const traced = traceFabric({ // --> tracedFabric value AND traced\n * innerArray: [1, 2, 3], // --> tracedValue AND traced\n * });\n *\n * isTracedFabric(traced.value); // true\n * isTracedFabric(traced.value.innerArray); // false\n * ```\n *\n * @see {@link https://traced-fabric.github.io/core/check-if-value-traced/isTracedFabric.html Wiki page.}\n *\n * @since 0.2.0\n */\nexport function isTracedFabric(value: any): boolean {\n return tracedFabricsTrace.has(value);\n}\n\n/**\n * Checks if the given value is a `tracedValue`.\n *\n * @example\n * ```typescript\n * const traced = traceFabric({ // --> tracedFabric value AND traced\n * innerArray: [1, 2, 3], // --> tracedValue AND traced\n * });\n *\n * isTracedValue(traced.value); // false\n * isTracedValue(traced.value.innerArray); // true\n * ```\n *\n * @see {@link https://traced-fabric.github.io/core/check-if-value-traced/isTracedValue.html Wiki page.}\n *\n * @since 0.2.0\n */\nexport function isTracedValue(value: any): boolean {\n return tracedValuesMetadata.has(value);\n}\n\n/**\n * Checks if the given value is a `traced`.\n *\n * @example\n * ```typescript\n * const traced = traceFabric({ // --> tracedFabric value AND traced\n * innerArray: [1, 2, 3], // --> tracedValue AND traced\n * });\n *\n * isTraced(traced.value); // true\n * isTraced(traced.value.innerArray); // true\n * ```\n *\n * @see {@link https://traced-fabric.github.io/core/check-if-value-traced/isTraced.html Wiki page.}\n *\n * @since 0.2.0\n */\nexport function isTraced(value: any): boolean {\n return isTracedValue(value) || isTracedFabric(value);\n}\n","/**\n * @source [tc39 / proposal weakrefs](https://github.com/tc39/proposal-weakrefs?tab=readme-ov-file#iterable-weakmaps)\n */\nexport class IterableWeakMap<\n _KEY extends object,\n _VALUE extends object,\n> {\n #weakKeySet = new Set>();\n #weakMap = new WeakMap<\n _KEY,\n { value: _VALUE; weakKey: WeakRef<_KEY> }\n >();\n\n #cleanupRegistry = new FinalizationRegistry((weakRef: WeakRef<_KEY>) => this.#weakKeySet.delete(weakRef));\n\n set(key: _KEY, value: _VALUE): this {\n const entry = this.#weakMap.get(key);\n\n if (entry) {\n entry.value = value;\n return this;\n }\n\n const weakKey = new WeakRef(key);\n\n this.#weakMap.set(key, { value, weakKey });\n this.#weakKeySet.add(weakKey);\n this.#cleanupRegistry.register(key, weakKey, weakKey);\n\n return this;\n }\n\n get(key: _KEY): _VALUE | undefined {\n return this.#weakMap.get(key)?.value;\n }\n\n has(key: _KEY): boolean {\n return this.#weakMap.has(key);\n }\n\n delete(key: _KEY): boolean {\n const entry = this.#weakMap.get(key);\n if (!entry) return false;\n\n this.#weakMap.delete(key);\n this.#weakKeySet.delete(entry.weakKey);\n this.#cleanupRegistry.unregister(entry.weakKey);\n\n return true;\n }\n\n *[Symbol.iterator](): IterableIterator<[key: _KEY, value: _VALUE]> {\n for (const ref of this.#weakKeySet) {\n const key = ref.deref();\n if (!key) continue;\n\n const mapValue = this.#weakMap.get(key);\n if (!mapValue) continue;\n\n yield [key, mapValue.value];\n }\n }\n\n entries(): IterableIterator<[key: _KEY, value: _VALUE]> {\n return this[Symbol.iterator]();\n }\n}\n","import type { JSONStructure } from '../types/json';\nimport type { TMutationCallback } from '../types/mutation';\n\nexport const mutationCallbacks = new WeakMap();\n","import type { JSONStructure, JSONValue } from '../types/json';\nimport type { TMutation } from '../types/mutation';\nimport { isStructure } from '../utils/isStructure';\nimport { isTracedFabric } from '../utils/isTraced';\nimport { IterableWeakMap } from '../utils/iterableWeakMap';\nimport { getRootRef, getStrongMetadata, getTargetChain, type TTracedValueMetadata, type TWeakTracedValueMetadata } from './metadata';\nimport { mutationCallbacks } from './mutationCallback';\nimport { tracedFabricsTrace } from './traces';\n\nconst tracedFabricSubscribers = new WeakMap<\n JSONStructure, // the sender of the updates (if update happen, this value will send the updates to receivers)\n IterableWeakMap<\n JSONStructure, // receiver of the updates\n TWeakTracedValueMetadata[] // set of childMetadata (the path to the sender in receiver's value)\n >\n>();\n\nexport function addTracedSubscriber(\n changesSender: JSONStructure,\n metadata: TTracedValueMetadata,\n): void {\n const subscribers\n = tracedFabricSubscribers.get(changesSender)\n ?? tracedFabricSubscribers.set(changesSender, new IterableWeakMap()).get(changesSender)!;\n\n const rootRef = getRootRef(metadata.parentRef);\n if (!rootRef) return;\n\n const receiver = subscribers.get(rootRef) ?? subscribers.set(rootRef, []).get(rootRef)!;\n\n receiver.push({ parentRef: new WeakRef(metadata.parentRef), key: metadata.key });\n}\n\n/**\n * Will unsubscribe the `receiver` from the `sender`.\n * So after mutating the `sender`, the `receiver` will not receive any updates.\n *\n * Needs to be used to speed up garbage collection.\n *\n * @param changesSender the `sender` of the updates (value that is a part of the receiver).\n * @param changesReceiver `receiver` of the updates.\n *\n * @example\n * ```typescript\n * const globalMessages = traceFabric(['Welcome!']);\n *\n * function userLifecycle(): void {\n * const user = traceFabric({\n * globalMessages: globalMessages.value,\n * });\n *\n * // The `globalMessages` subscribes to the `user` value to send updates.\n * // To speed up the gc, remove the subscription, at the end of the `user` lifecycle.\n * removeTraceSubscription(globalMessages.value, user.value);\n * }\n * ```\n *\n * @since 0.4.0\n */\nexport function removeTraceSubscription(\n changesSender: JSONStructure,\n changesReceiver: JSONStructure,\n): void {\n const subscribers = tracedFabricSubscribers.get(changesSender);\n if (!subscribers) return;\n\n subscribers.delete(changesReceiver);\n}\n\nexport function removeTracedSubscriber(\n changesSender: JSONStructure,\n metadata: TTracedValueMetadata,\n): void {\n const subscribers = tracedFabricSubscribers.get(changesSender);\n if (!subscribers) return;\n\n const rootRef = getRootRef(metadata.parentRef);\n if (!rootRef) return;\n\n const receiver = subscribers.get(rootRef);\n if (!receiver) return;\n\n const index = receiver.findIndex(m => m.key === metadata.key && m.parentRef.deref() === metadata.parentRef);\n\n if (index !== -1) receiver.splice(index, 1);\n}\n\nexport function removeNestedTracedSubscribers(\n changesSender: JSONStructure,\n metadata: TTracedValueMetadata,\n): void {\n const target = (metadata.parentRef as any)[metadata.key] as JSONValue | undefined;\n if (!isStructure(target)) return;\n\n if (isTracedFabric(target)) return removeTracedSubscriber(changesSender, metadata);\n\n for (const key in target) {\n const maybeIndex = Number.isNaN(+key) ? key : +key;\n const child = (target as any)[maybeIndex] as JSONValue;\n\n if (!isStructure(child)) continue;\n\n const childMetadata = getStrongMetadata(child);\n\n if (childMetadata) removeNestedTracedSubscribers(target, childMetadata);\n else if (isTracedFabric(child)) removeTracedSubscriber(child, { parentRef: target, key: maybeIndex });\n }\n}\n\nexport function updateSubscribers(\n changesSender: JSONStructure,\n mutation: TMutation,\n): void {\n const subscribers = tracedFabricSubscribers.get(changesSender);\n if (!subscribers) return;\n\n for (const [receiver, metadata] of subscribers.entries()) {\n const trace = tracedFabricsTrace.get(receiver);\n const receiverMutationCallback = mutationCallbacks.get(receiver);\n\n if (!trace || !receiverMutationCallback) continue;\n\n for (const trace of metadata) {\n const parentRef = trace.parentRef.deref();\n\n const targetChain = (parentRef ? getTargetChain(parentRef) : [])\n .concat(trace.key)\n .concat(mutation.targetChain);\n\n const traceLog = { ...mutation, targetChain };\n\n receiverMutationCallback(traceLog);\n }\n }\n}\n","import type { JSONValue } from './json';\n\nexport enum EMutated {\n object = 'object',\n array = 'array',\n}\n\nexport type TTarget = string | number;\n\nexport enum EObjectMutation {\n set = 'set',\n delete = 'delete',\n}\n\nexport type TObjectMutation = {\n mutated: EMutated.object;\n targetChain: TTarget[];\n} & ({\n type: EObjectMutation.set;\n value: JSONValue;\n} | {\n type: EObjectMutation.delete;\n value?: never;\n});\n\nexport enum EArrayMutation {\n set = 'set',\n delete = 'delete',\n\n push = 'push',\n reverse = 'reverse',\n shift = 'shift',\n unshift = 'unshift',\n}\n\nexport type TArrayMutation = {\n mutated: EMutated.array;\n targetChain: TTarget[];\n} & ({\n type: EArrayMutation.set;\n value: JSONValue;\n} | {\n type:\n EArrayMutation.push |\n EArrayMutation.unshift;\n value: JSONValue[];\n} | {\n type:\n EArrayMutation.delete |\n EArrayMutation.reverse |\n EArrayMutation.shift;\n value?: never;\n});\n\nexport type TMutation = TObjectMutation | TArrayMutation;\n\nexport type TMutationCallback = (mutation: TMutation) => void;\n","import type { JSONStructure } from '../types/json';\n\nconst disabledTracingSymbol = Symbol('disabledTracing');\n\n/**\n * Check if the given value has `tracing` enabled.\n *\n * @param value - the value to check.\n * @returns `true` if the value is enabled for tracing, `false` otherwise.\n *\n * @example\n * ```typescript\n * const fabric = traceFabric({\n * tracedArray: [1, 2, 3],\n * untracedArray: disableTracing([4, 5, 6]),\n * });\n *\n * console.log(isTracingEnabled(fabric.value.tracedArray)); // true;\n * console.log(isTracingEnabled(fabric.value.untracedArray)); // false;\n * ```\n *\n * @see {@link https://traced-fabric.github.io/core/disable-tracing/isTracingEnabled.html Wiki page.}\n *\n * @since 0.10.0\n */\nexport function isTracingEnabled(value: T): boolean {\n return !(disabledTracingSymbol in value);\n}\n\n/**\n * Disable `tracing` for the given value.\n *\n * Primarily used for static values that should not be traced or modified,\n * also to reduce memory usage and improve performance.\n * The value will be modifiable, but the `mutations` will not be recorded.\n *\n * @param value - the value to disable tracing.\n * @returns same as the given **value** with tracing disabled.\n *\n * @example\n * ```typescript\n * const fabric = traceFabric({\n * tracedArray: [1, 2, 3],\n * untracedArray: disableTracing([4, 5, 6]),\n * });\n *\n * console.log(isTracingEnabled(fabric.value.tracedArray)); // true;\n * console.log(isTracingEnabled(fabric.value.untracedArray)); // false;\n * ```\n *\n * @see {@link https://traced-fabric.github.io/core/disable-tracing/disableTracing.html Wiki page.}\n *\n * @since 0.10.0\n */\nexport function disableTracing(value: T): T {\n (value as any)[disabledTracingSymbol] = true;\n return value as ReturnType>;\n}\n\n/**\n * Enable `tracing` for the given value.\n *\n * [!NOTE] This function will not enable `mutations` recording for the value that is\n * already part of the `tracedFabric`, because it was not processed to be a `tracedValue`.\n * To do so, please use this approach:\n * ```typescript\n * withoutTracing(() => {\n * fabric.value.untracedArray = enableTracing(fabric.value.untracedArray);\n * });\n * ```\n *\n * @param value - the value to enable tracing.\n * @returns same as the given **value** with tracing enabled.\n *\n * @example\n * ```typescript\n * const fabric = traceFabric({\n * tracedArray: [1, 2, 3],\n * untracedArray: disableTracing([4, 5, 6]),\n * });\n *\n * console.log(isTracingEnabled(fabric.value.tracedArray)); // true;\n * console.log(isTracingEnabled(fabric.value.untracedArray)); // false;\n *\n * withoutTracing(() => {\n * fabric.value.untracedArray = enableTracing(fabric.value.untracedArray);\n * });\n *\n * console.log(isTracingEnabled(fabric.value.untracedArray)); // true;\n * ```\n *\n * @see {@link https://traced-fabric.github.io/core/disable-tracing/enableTracing.html Wiki page.}\n *\n * @since 0.10.0\n */\nexport function enableTracing(value: T): T {\n delete (value as any)[disabledTracingSymbol];\n return value as ReturnType>;\n}\n","let allowAssigning = true;\n\n/**\n * Check if `assigning` is enabled. If the assigning is enabled, the `traced` object assignment works as usual.\n * If the assigning is disabled, the `traced` object assignment does not work.\n *\n * @returns true if `assigning` is enabled, false otherwise\n *\n * @example\n * ```typescript\n * console.log(isAssigning()); // true\n *\n * withoutAssigning(() => {\n * console.log(isAssigning()); // false\n * });\n * ```\n *\n * @see {@link https://traced-fabric.github.io/core/ignore-assigning/isAssigning.html Wiki page.}\n *\n * @since 0.12.0\n */\nexport function isAssigning(): boolean {\n return !!allowAssigning;\n}\n\n/**\n * Ignores any modification to a `traced` structure in the given function (deleting, adding, or changing the values).\n * The function should not be async, as it turns off the `assigning` globally.\n *\n * @warn Use with caution, as it can lead to breaking `applyTrace` function, because `traced` items inside of the function will not recorded any modification.\n *\n * @param callback - function in which `assigning` is disabled\n * @returns same as the return value of the given function\n *\n * @example\n * ```typescript\n * const fabric = traceFabric({ season: 'winter' });\n * fabric.value.season = 'spring'; // assignment is recorded\n *\n * withoutAssigning(() => {\n * fabric.value.season = 'summer'; // assignment is NOT recorded\n * });\n *\n * console.log(fabric.value);\n * // { season: 'spring' }\n * ```\n *\n * @see {@link https://traced-fabric.github.io/core/ignore-assigning/withoutAssigning.html Wiki page.}\n *\n * @since 0.12.0\n */\nexport function withoutAssigning(callback: () => T): T {\n allowAssigning = false;\n const result = callback();\n allowAssigning = true;\n\n return result;\n}\n","let allowTracing = true;\n\n/**\n * Check if `tracing` is enabled. If the tracing is enabled, the `mutations` are recorded in the trace.\n *\n * @returns true if `tracing` is enabled, false otherwise\n *\n * @example\n * ```typescript\n * console.log(isTracing()); // true\n *\n * withoutTracing(() => {\n * console.log(isTracing()); // false\n * });\n * ```\n *\n * @see {@link https://traced-fabric.github.io/core/ignore-tracing/isTracing.html Wiki page.}\n *\n * @since 0.2.0\n */\nexport function isTracing(): boolean {\n return !!allowTracing;\n}\n\n/**\n * Ignores recording of all `mutations` to `trace` in the given function.\n * The function should not be async, as it turns off the tracing globally.\n *\n * @warn Use with caution, as it can lead to breaking `applyTrace` function, because of the missing mutations.\n *\n * @param callback - function in which `tracing` is disabled\n * @returns same as the return value of the given function\n *\n * @example\n * ```typescript\n * const fabric = traceFabric({ season: 'winter' });\n * fabric.value.season = 'spring'; // adds mutation to the traceLogs\n *\n * withoutTracing(() => {\n * fabric.value.season = 'summer'; // no mutation is added to the traceLogs\n * });\n *\n * console.log(fabric.trace);\n * // [{\n * // mutated: \"object\",\n * // targetChain: [ \"season\" ],\n * // value: \"spring\",\n * // type: \"set\",\n * // }]\n * ```\n *\n * @see {@link https://traced-fabric.github.io/core/ignore-tracing/withoutTracing.html Wiki page.}\n *\n * @since 0.2.0\n */\nexport function withoutTracing(callback: () => T): T {\n allowTracing = false;\n const result = callback();\n allowTracing = true;\n\n return result;\n}\n","import type { JSONArray, JSONObject, JSONStructure } from './types/json';\nimport {\n EArrayMutation,\n EMutated,\n EObjectMutation,\n type TArrayMutation,\n type TMutation,\n type TObjectMutation,\n type TTarget,\n} from './types/mutation';\n\nfunction applyObjectMutation(value: JSONObject, mutation: TObjectMutation): void {\n const lastKey = mutation.targetChain.at(-1);\n if (lastKey === undefined) throw new Error('Invalid target chain');\n\n if (mutation.type === EObjectMutation.set) {\n value[lastKey] = mutation.value;\n }\n else if (mutation.type === EObjectMutation.delete) {\n delete value[lastKey.toString()];\n }\n}\n\nfunction applyArrayMutation(value: JSONArray, mutation: TArrayMutation): void {\n const lastKey = mutation.targetChain.at(-1);\n if (lastKey === undefined) throw new Error('Invalid target chain');\n\n if (mutation.type === EArrayMutation.set) value[lastKey as number] = mutation.value;\n else if (mutation.type === EArrayMutation.delete) value.splice(lastKey as number, 1);\n else if (mutation.type === EArrayMutation.push) value.push(...mutation.value);\n else if (mutation.type === EArrayMutation.reverse) value.reverse();\n else if (mutation.type === EArrayMutation.shift) value.shift();\n else if (mutation.type === EArrayMutation.unshift) value.unshift(...mutation.value);\n}\n\nfunction getMutationTargetWithoutLastKey(\n value: JSONStructure,\n targetChain: TTarget[],\n): JSONStructure {\n let target = value;\n\n for (let i = 0; i < targetChain.length - 1; i++) {\n if (targetChain[i] in target) target = (target as any)[targetChain[i]];\n else throw new Error('Invalid target chain');\n }\n\n return target;\n}\n\n/**\n * Applies `tracedFabric` `mutations` to the given value.\n * The value should have the same state as the `traceFabric` value before allied mutations.\n *\n * @WARN This function mutates the value directly.\n *\n * @see {@link https://traced-fabric.github.io/core/core-functions/applyTrace.html Wiki page.}\n *\n * @param value - the object to which the **trace** will be directly applied.\n * @param trace - the `trace` (array of `mutations`) to apply to the given **value**.\n *\n * @example\n * ```typescript\n * const fabric = traceFabric({ season: 'winter' });\n * const target = { season: 'winter' };\n *\n * target.season = 'summer';\n *\n * applyTrace(target, fabric.trace);\n *\n * console.log(target); // { season: 'summer' }\n * ```\n *\n * @since 0.0.1\n */\nexport function applyTrace(\n value: T,\n trace: TMutation[],\n): void {\n for (const mutation of trace) {\n const mutationTarget = getMutationTargetWithoutLastKey(value, mutation.targetChain);\n\n if (mutation.mutated === EMutated.object) applyObjectMutation(mutationTarget as JSONObject, mutation);\n else if (mutation.mutated === EMutated.array) applyArrayMutation(mutationTarget as JSONArray, mutation);\n }\n}\n","import { isStructure } from './utils/isStructure';\n\n// For tracedFabric structuredClone can't be used,\n// because it breaks when trying to copy traced values and general slowness.\n\n/**\n * Deep clone an object or array.\n *\n * Primarily used to clone `tracedFabric` and `tracedValues` without inheriting proxy traps,\n * and potentially breaking tracedFabric.\n *\n * @note `deepClone(...)` will not copy symbols\n *\n * @see {@link https://traced-fabric.github.io/core/core-functions/deepClone.html Wiki page.}\n *\n * @param value - The value to clone\n * @returns The cloned value\n *\n * @example\n * ```typescript\n * const fabric = traceFabric({ season: 'winter', bestDays: [2, 7, 16] });\n * const clone = deepClone(fabric.value);\n *\n * console.log(clone); // { season: 'winter', bestDays: [2, 7, 16] }\n * console.log(clone === fabric.value); // false\n * console.log(clone.bestDays === fabric.value.bestDays); // false\n * ```\n *\n * @since 0.0.1\n */\nexport function deepClone(value: T): T {\n if (!isStructure(value)) return value;\n\n const newValue = (Array.isArray(value) ? [] : {}) as typeof value;\n for (const i in value) newValue[i] = isStructure(value[i]) ? deepClone(value[i]) : value[i];\n\n return newValue;\n}\n","import { isAssigning } from '../../utils/withoutAssigning';\n\nexport const reflect = new Proxy(Reflect, {\n get(target, k) {\n const key = k as keyof typeof Reflect;\n\n if (typeof target[key] === 'function') {\n return (...args: any[]) => {\n if (isAssigning()) return (Reflect as any)[key](...args);\n return true;\n };\n }\n\n return target[key];\n },\n});\n","import type { JSONArray, JSONValue } from '../../types/json';\nimport { deepClone } from '../../deepClone';\nimport { EArrayMutation, EMutated, type TMutationCallback } from '../../types/mutation';\nimport { isStructure } from '../../utils/isStructure';\nimport { isTracing } from '../../utils/withoutTracing';\nimport { getMetadata, getTargetChain, type TTracedValueMetadata } from '../metadata';\nimport { removeNestedTracedSubscribers } from '../subscribers';\nimport { deepTrace } from './deepTrace';\nimport { reflect } from './reflect';\n\nconst mutated = EMutated.array;\n\nexport function getTracedProxyArray(\n value: T,\n mutationCallback: TMutationCallback,\n): T {\n const proxy = new WeakRef(new Proxy(value, {\n get(target, key, receiver) {\n if (key === EArrayMutation.push) {\n return (...args: JSONValue[]) => {\n const initialLength = target.length;\n const tracedArgs = args.map((arg, i) => deepTrace(arg, mutationCallback, {\n parentRef: receiver,\n key: initialLength + i,\n }));\n\n if (isTracing()) {\n if (args.length > 1) {\n mutationCallback({\n mutated,\n targetChain: getTargetChain(receiver),\n value: deepClone(args),\n type: key,\n });\n }\n else {\n mutationCallback({\n mutated,\n targetChain: [...getTargetChain(receiver), initialLength],\n value: deepClone(args[0]),\n type: EArrayMutation.set,\n });\n }\n }\n\n return reflect.apply(target.push, target, tracedArgs);\n };\n }\n\n else if (\n key === EArrayMutation.reverse\n || key === EArrayMutation.shift\n ) {\n // if majority of array items are changed their positions\n // their target chain should be updated\n // so if in the future we will reference them, the reference chain will be correct\n return () => {\n for (let i = 0; i < target.length; i++) {\n const item = target[i];\n if (!isStructure(item)) continue;\n\n const metadata = getMetadata(item);\n if (metadata) metadata.key = target.length - i - 1;\n }\n\n if (isTracing()) mutationCallback({ mutated, targetChain: getTargetChain(receiver), type: key });\n\n return reflect.apply(target[key], target, []);\n };\n }\n\n else if (key === EArrayMutation.unshift) {\n return (...args: JSONValue[]) => {\n const initialLength = target.length;\n const tracedArgs = args.map((arg, i) => deepTrace(arg, mutationCallback, {\n parentRef: receiver,\n key: initialLength + i,\n }));\n\n if (isTracing()) {\n mutationCallback({\n mutated,\n targetChain: getTargetChain(receiver),\n value: deepClone(args),\n type: key,\n });\n }\n\n // before unshifting we should update the target chain of all items\n // that are already nested in the array\n for (let i = 0; i < target.length; i++) {\n const item = target[i];\n if (!isStructure(item)) continue;\n\n const metadata = getMetadata(item);\n if (metadata) metadata.key = initialLength + i;\n }\n\n return reflect.apply(target.unshift, target, tracedArgs);\n };\n }\n\n return Reflect.get(target, key);\n },\n\n set(target, key, value, receiver) {\n if (typeof key === 'symbol') return reflect.set(target, key, value);\n\n const index = +key;\n\n // ignoring non-integer keys (for example 'length')\n if (Number.isNaN(index)) return reflect.set(target, key, value);\n\n const childMetadata: TTracedValueMetadata = { parentRef: receiver, key: index };\n\n // if the value that is overridden and it is a tracedFabric,\n // we should remove the subscriber from the old value\n if (isStructure(target[index])) removeNestedTracedSubscribers(target[index], childMetadata);\n\n if (isTracing()) {\n mutationCallback({\n mutated,\n targetChain: [...getTargetChain(receiver), index],\n value: deepClone(value),\n type: EArrayMutation.set,\n });\n }\n\n return reflect.set(target, key, deepTrace(value, mutationCallback, childMetadata));\n },\n\n deleteProperty(target, key) {\n if (typeof key === 'symbol') return reflect.set(target, key, value);\n\n const index = +key;\n\n if (Number.isNaN(index)) return reflect.deleteProperty(target, key);\n\n const ref = proxy.deref();\n if (!ref) return reflect.deleteProperty(target, key);\n\n if (isStructure(target[index])) {\n removeNestedTracedSubscribers(target[index], {\n parentRef: ref,\n key: index,\n });\n }\n\n if (isTracing()) {\n mutationCallback({\n mutated,\n targetChain: [...getTargetChain(ref), index],\n type: EArrayMutation.delete,\n });\n }\n\n return reflect.deleteProperty(target, key);\n },\n }));\n\n return proxy.deref() as T;\n}\n","import type { JSONObject } from '../../types/json';\nimport { deepClone } from '../../deepClone';\nimport { EMutated, EObjectMutation, type TMutationCallback } from '../../types/mutation';\nimport { isStructure } from '../../utils/isStructure';\nimport { isTracing } from '../../utils/withoutTracing';\nimport { getTargetChain, type TTracedValueMetadata } from '../metadata';\nimport { removeNestedTracedSubscribers } from '../subscribers';\nimport { deepTrace } from './deepTrace';\nimport { reflect } from './reflect';\n\nconst mutated = EMutated.object;\n\nexport function getTracedProxyObject(\n value: T,\n mutationCallback: TMutationCallback,\n): T {\n const proxy = new WeakRef(new Proxy(value, {\n set(target, key, value, receiver) {\n if (typeof key === 'symbol') return reflect.set(target, key, value);\n\n const childMetadata: TTracedValueMetadata = { parentRef: receiver, key };\n\n // if the value that is overridden and it is a tracedFabric,\n // we should remove the subscriber from the old value\n if (isStructure(target[key])) removeNestedTracedSubscribers(target[key], childMetadata);\n\n if (isTracing()) {\n mutationCallback({\n mutated,\n targetChain: [...getTargetChain(receiver), key],\n value: deepClone(value),\n type: EObjectMutation.set,\n });\n }\n\n return reflect.set(target, key, deepTrace(value, mutationCallback, childMetadata));\n },\n\n deleteProperty(target, key) {\n if (typeof key === 'symbol') return reflect.set(target, key, value);\n\n const ref = proxy.deref();\n if (!ref) return reflect.deleteProperty(target, key);\n\n if (isStructure(target[key])) removeNestedTracedSubscribers(target[key], { parentRef: ref, key });\n\n if (isTracing()) {\n mutationCallback({\n mutated,\n targetChain: [...getTargetChain(ref), key],\n type: EObjectMutation.delete,\n });\n }\n\n return reflect.deleteProperty(target, key);\n },\n }));\n\n return proxy.deref() as T;\n}\n","import type { JSONValue } from '../../types/json';\nimport type { TMutationCallback } from '../../types/mutation';\nimport { isTracingEnabled } from '../../utils/disableTracing';\nimport { isStructure } from '../../utils/isStructure';\nimport { isTracedFabric } from '../../utils/isTraced';\nimport { setMetadata, type TTracedValueMetadata } from '../metadata';\nimport { mutationCallbacks } from '../mutationCallback';\nimport { addTracedSubscriber } from '../subscribers';\nimport { tracedFabricsTrace } from '../traces';\nimport { getTracedProxyArray } from './getTracedArray';\nimport { getTracedProxyObject } from './getTracedObject';\n\n// what this function should do:\n// * will trace the given value recursively\n// * will set the tracedFabric references\n// * will set the tracedValues metadata\n// * if the value is already a traced fabric, return as is\n// * if the value is not a structure (Object/Array), return as is\nexport function deepTrace(\n value: T,\n mutationCallback: TMutationCallback,\n metadata?: TTracedValueMetadata,\n): T {\n // if data type is common and not structure-like, return as is\n if (!isStructure(value)) return value;\n\n // if the given value is already disabled for tracing, return as is\n if (!isTracingEnabled(value)) return value;\n\n // if the given value is already traced (tracedFabric),\n // we should subscribe the current value to metadata root(tracedFabric)\n if (isTracedFabric(value)) {\n if (metadata) addTracedSubscriber(value, metadata);\n\n return value;\n }\n\n // if we found that the given value is an object-like structure:\n // 1. apply the tracing behavior to the given value\n // 2. iterate over the object, to see if keys\n // are also objects-like structures and trace them recursively\n const proxy = Array.isArray(value)\n ? getTracedProxyArray(value, mutationCallback)\n : getTracedProxyObject(value, mutationCallback);\n\n if (metadata) {\n setMetadata(proxy, metadata);\n }\n else {\n tracedFabricsTrace.set(proxy, []);\n mutationCallbacks.set(proxy, mutationCallback);\n }\n\n for (const key in value) {\n if (!isStructure(value[key])) continue;\n\n const maybeNumber = Number.isNaN(+key) ? key : +key;\n value[key] = deepTrace(value[key], mutationCallback, { parentRef: proxy, key: maybeNumber });\n }\n\n return proxy as T;\n}\n","import type { JSONStructure } from './types/json';\nimport type { TMutation, TMutationCallback } from './types/mutation';\nimport type { TOnMutation, TTracedFabric } from './types/tracedFabric';\nimport { deepTrace } from './core/proxy/deepTrace';\nimport { updateSubscribers } from './core/subscribers';\nimport { tracedFabricsTrace } from './core/traces';\nimport { isTracingEnabled } from './utils/disableTracing';\nimport { withoutTracing } from './utils/withoutTracing';\n\n/**\n * Track the mutation of a given JSON-like object or array.\n * Other `tracedFabric` can be nested inside.\n *\n * The `trace` (array of `mutations`), that is produced by the `tracedFabric` on values mutation,\n * can be used to apply them to other objects or arrays, using the `applyTrace(...)` function.\n *\n * @see {@link https://traced-fabric.github.io/core/core-functions/traceFabric.html Wiki page.}\n *\n * @param {JSONStructure} value an object or array that will be deeply tracked. Value is JSON.stringify safe. The type of the value should be the same as JSONStructure.\n * @param {TOnMutation} [onMutation] a function that is triggered when the `traced` value is mutated. The function receives the `mutation` as an argument and should return the `mutation` to be saved to the `trace`. If no modification is needed, return the original mutation; otherwise, return the modified mutation for storage.\n *\n * @returns {TTracedFabric} Object with the following properties:\n * - **value** - the `traced` proxy of the given **value**.\n * - **trace** - the array of `mutations` that are made to the **value**.\n * - **clearTrace** - a function that clears the trace.\n *\n * @example\n * ```typescript\n * const bestDays = traceFabric([2, 7, 16]);\n * const fabric = traceFabric({\n * season: 'winter',\n * bestDays: bestDays.value,\n * });\n *\n * fabric.value.season = 'summer';\n * fabric.value.bestDays.push(25);\n * bestDays.value.push(26);\n *\n * console.log(fabric.trace);\n * // [{\n * // mutated: 'object', type: 'set',\n * // targetChain: ['season'],\n * // value: 'summer',\n * // }, {\n * // mutated: 'array', type: 'set',\n * // targetChain: ['bestDays', 3],\n * // value: 25,\n * // }, {\n * // mutated: 'array', type: 'set',\n * // targetChain: ['bestDays', 4],\n * // value: 26,\n * // }]\n * ```\n *\n * @since 0.0.1\n */\nexport function traceFabric<\n T extends JSONStructure = JSONStructure,\n _MUTATION = TMutation,\n>(\n value: T,\n onMutation?: TOnMutation<_MUTATION>,\n): TTracedFabric {\n if (!isTracingEnabled(value)) throw new Error('Cannot create traceFabric when tracing is disabled.');\n\n let proxyRef: T;\n\n const trace = (): _MUTATION[] => tracedFabricsTrace.get(proxyRef)!;\n const setTrace = (newTrace: _MUTATION[]): void => {\n tracedFabricsTrace.set(proxyRef, newTrace);\n };\n const clearTrace = (): void => setTrace([]);\n\n const mutationCallback: TMutationCallback = (mutation) => {\n trace()?.push(onMutation?.(mutation) ?? mutation as _MUTATION);\n updateSubscribers(proxyRef, mutation);\n };\n\n proxyRef = withoutTracing(() => deepTrace(value, mutationCallback));\n\n return {\n value: proxyRef,\n\n get trace() { return trace(); },\n set trace(newTrace: _MUTATION[]) { setTrace(newTrace); },\n\n clearTrace,\n };\n}\n"],"names":["trace","EMutated","EObjectMutation","EArrayMutation","mutated","value"],"mappings":"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"}