{"version":3,"file":"index.umd.js","sources":["../src/index.ts"],"sourcesContent":["// symbols\nconst TRACK_MEMO_SYMBOL = Symbol();\nconst GET_ORIGINAL_SYMBOL = Symbol();\n\n// properties\nconst AFFECTED_PROPERTY = 'a';\nconst IS_TARGET_COPIED_PROPERTY = 'f';\nconst PROXY_PROPERTY = 'p';\nconst PROXY_CACHE_PROPERTY = 'c';\nconst TARGET_CACHE_PROPERTY = 't';\nconst NEXT_OBJECT_PROPERTY = 'n';\nconst CHANGED_PROPERTY = 'g';\nconst HAS_KEY_PROPERTY = 'h';\nconst ALL_OWN_KEYS_PROPERTY = 'w';\nconst HAS_OWN_KEY_PROPERTY = 'o';\nconst KEYS_PROPERTY = 'k';\n\n// function to create a new bare proxy\nlet newProxy = <T extends object>(\n  target: T,\n  handler: ProxyHandler<T>,\n) => new Proxy(target, handler);\n\n// get object prototype\nconst getProto = Object.getPrototypeOf;\n\nconst objectsToTrack = new WeakMap<object, boolean>();\n\n// check if obj is a plain object or an array\nconst isObjectToTrack = <T>(obj: T): obj is T extends object ? T : never => (\n  obj && (objectsToTrack.has(obj as unknown as object)\n    ? objectsToTrack.get(obj as unknown as object) as boolean\n    : (getProto(obj) === Object.prototype || getProto(obj) === Array.prototype)\n  )\n);\n\n// check if it is object\nconst isObject = (x: unknown): x is object => (\n  typeof x === 'object' && x !== null\n);\n\n// Properties that are both non-configurable and non-writable will break\n// the proxy get trap when we try to return a recursive/child compare proxy\n// from them. We can avoid this by making a copy of the target object with\n// all descriptors marked as configurable, see `copyTargetObject`.\n// See: https://github.com/dai-shi/proxy-compare/pull/8\nconst needsToCopyTargetObject = (obj: object) => (\n  Object.values(Object.getOwnPropertyDescriptors(obj)).some(\n    (descriptor) => !descriptor.configurable && !descriptor.writable,\n  )\n);\n\n// Make a copy with all descriptors marked as configurable.\nconst copyTargetObject = <T extends object>(obj: T): T => {\n  if (Array.isArray(obj)) {\n    // Arrays need a special way to copy\n    return Array.from(obj) as T;\n  }\n  // For non-array objects, we create a new object keeping the prototype\n  // with changing all configurable options (otherwise, proxies will complain)\n  const descriptors = Object.getOwnPropertyDescriptors(obj);\n  Object.values(descriptors).forEach((desc) => { desc.configurable = true; });\n  return Object.create(getProto(obj), descriptors);\n};\n\ntype HasKeySet = Set<string | symbol>\ntype HasOwnKeySet = Set<string | symbol>\ntype KeysSet = Set<string | symbol>\ntype Used = {\n  [HAS_KEY_PROPERTY]?: HasKeySet;\n  [ALL_OWN_KEYS_PROPERTY]?: true;\n  [HAS_OWN_KEY_PROPERTY]?: HasOwnKeySet;\n  [KEYS_PROPERTY]?: KeysSet;\n};\ntype Affected = WeakMap<object, Used>;\ntype ProxyHandlerState<T extends object> = {\n  readonly [IS_TARGET_COPIED_PROPERTY]: boolean;\n  [PROXY_PROPERTY]?: T;\n  [PROXY_CACHE_PROPERTY]?: ProxyCache<object> | undefined;\n  [TARGET_CACHE_PROPERTY]?: TargetCache<object> | undefined;\n  [AFFECTED_PROPERTY]?: Affected;\n}\ntype ProxyCache<T extends object> = WeakMap<\n  object,\n  readonly [ProxyHandler<T>, ProxyHandlerState<T>]\n>;\ntype TargetCache<T extends object> = WeakMap<\n  object,\n  readonly [target: T, copiedTarget?: T]\n>;\n\nconst createProxyHandler = <T extends object>(origObj: T, isTargetCopied: boolean) => {\n  const state: ProxyHandlerState<T> = {\n    [IS_TARGET_COPIED_PROPERTY]: isTargetCopied,\n  };\n  let trackObject = false; // for trackMemo\n  const recordUsage = (\n    type:\n      | typeof HAS_KEY_PROPERTY\n      | typeof ALL_OWN_KEYS_PROPERTY\n      | typeof HAS_OWN_KEY_PROPERTY\n      | typeof KEYS_PROPERTY,\n    key?: string | symbol,\n  ) => {\n    if (!trackObject) {\n      let used = (state[AFFECTED_PROPERTY] as Affected).get(origObj);\n      if (!used) {\n        used = {};\n        (state[AFFECTED_PROPERTY] as Affected).set(origObj, used);\n      }\n      if (type === ALL_OWN_KEYS_PROPERTY) {\n        used[ALL_OWN_KEYS_PROPERTY] = true;\n      } else {\n        let set = used[type];\n        if (!set) {\n          set = new Set();\n          used[type] = set;\n        }\n        set.add(key as string | symbol);\n      }\n    }\n  };\n  const recordObjectAsUsed = () => {\n    trackObject = true;\n    (state[AFFECTED_PROPERTY] as Affected).delete(origObj);\n  };\n  const handler: ProxyHandler<T> = {\n    get(target, key) {\n      if (key === GET_ORIGINAL_SYMBOL) {\n        return origObj;\n      }\n      recordUsage(KEYS_PROPERTY, key);\n      return createProxy(\n        Reflect.get(target, key),\n        (state[AFFECTED_PROPERTY] as Affected),\n        state[PROXY_CACHE_PROPERTY],\n        state[TARGET_CACHE_PROPERTY],\n      );\n    },\n    has(target, key) {\n      if (key === TRACK_MEMO_SYMBOL) {\n        recordObjectAsUsed();\n        return true;\n      }\n      recordUsage(HAS_KEY_PROPERTY, key);\n      return Reflect.has(target, key);\n    },\n    getOwnPropertyDescriptor(target, key) {\n      recordUsage(HAS_OWN_KEY_PROPERTY, key);\n      return Reflect.getOwnPropertyDescriptor(target, key);\n    },\n    ownKeys(target) {\n      recordUsage(ALL_OWN_KEYS_PROPERTY);\n      return Reflect.ownKeys(target);\n    },\n  };\n  if (isTargetCopied) {\n    handler.set = handler.deleteProperty = () => false;\n  }\n  return [handler, state] as const;\n};\n\nconst getOriginalObject = <T extends object>(obj: T) => (\n  // unwrap proxy\n  (obj as { [GET_ORIGINAL_SYMBOL]?: typeof obj })[GET_ORIGINAL_SYMBOL]\n  // otherwise\n  || obj\n);\n\n/**\n * Create a proxy.\n *\n * This function will create a proxy at top level and proxy nested objects as you access them,\n * in order to keep track of which properties were accessed via get/has proxy handlers:\n *\n * NOTE: Printing of WeakMap is hard to inspect and not very readable\n * for this purpose you can use the `affectedToPathList` helper.\n *\n * @param {object} obj - Object that will be wrapped on the proxy.\n * @param {WeakMap<object, unknown>} affected -\n * WeakMap that will hold the tracking of which properties in the proxied object were accessed.\n * @param {WeakMap<object, unknown>} [proxyCache] -\n * WeakMap that will help keep referential identity for proxies.\n * @returns {Proxy<object>} - Object wrapped in a proxy.\n *\n * @example\n * import { createProxy } from 'proxy-compare';\n *\n * const original = { a: \"1\", c: \"2\", d: { e: \"3\" } };\n * const affected = new WeakMap();\n * const proxy = createProxy(original, affected);\n *\n * proxy.a // Will mark as used and track its value.\n * // This will update the affected WeakMap with original as key\n * // and a Set with \"a\"\n *\n * proxy.d // Will mark \"d\" as accessed to track and proxy itself ({ e: \"3\" }).\n * // This will update the affected WeakMap with original as key\n * // and a Set with \"d\"\n */\nexport const createProxy = <T>(\n  obj: T,\n  affected: WeakMap<object, unknown>,\n  proxyCache?: WeakMap<object, unknown>,\n  targetCache?: WeakMap<object, unknown>,\n): T => {\n  if (!isObjectToTrack(obj)) return obj;\n  let targetAndCopied = (\n    targetCache && (targetCache as TargetCache<typeof obj>).get(obj)\n  );\n  if (!targetAndCopied) {\n    const target = getOriginalObject(obj);\n    if (needsToCopyTargetObject(target)) {\n      targetAndCopied = [target, copyTargetObject(target)];\n    } else {\n      targetAndCopied = [target];\n    }\n    targetCache?.set(obj, targetAndCopied);\n  }\n  const [target, copiedTarget] = targetAndCopied;\n  let handlerAndState = (\n    proxyCache && (proxyCache as ProxyCache<typeof target>).get(target)\n  );\n  if (\n    !handlerAndState\n    || handlerAndState[1][IS_TARGET_COPIED_PROPERTY] !== !!copiedTarget\n  ) {\n    handlerAndState = createProxyHandler<typeof target>(target, !!copiedTarget);\n    handlerAndState[1][PROXY_PROPERTY] = newProxy(\n      copiedTarget || target,\n      handlerAndState[0],\n    );\n    if (proxyCache) {\n      proxyCache.set(target, handlerAndState);\n    }\n  }\n  handlerAndState[1][AFFECTED_PROPERTY] = affected as Affected;\n  handlerAndState[1][PROXY_CACHE_PROPERTY] = proxyCache as ProxyCache<object> | undefined;\n  handlerAndState[1][TARGET_CACHE_PROPERTY] = targetCache as TargetCache<object> | undefined;\n  return handlerAndState[1][PROXY_PROPERTY] as typeof target;\n};\n\nconst isAllOwnKeysChanged = (prevObj: object, nextObj: object) => {\n  const prevKeys = Reflect.ownKeys(prevObj);\n  const nextKeys = Reflect.ownKeys(nextObj);\n  return prevKeys.length !== nextKeys.length\n    || prevKeys.some((k, i) => k !== nextKeys[i]);\n};\n\ntype ChangedCache = WeakMap<object, {\n  [NEXT_OBJECT_PROPERTY]: object;\n  [CHANGED_PROPERTY]: boolean;\n}>;\n\n/**\n * Compare changes on objects.\n *\n * This will compare the affected properties on tracked objects inside the proxy\n * to check if there were any changes made to it,\n * by default if no property was accessed on the proxy it will attempt to do a\n * reference equality check for the objects provided (Object.is(a, b)). If you access a property\n * on the proxy, then isChanged will only compare the affected properties.\n *\n * @param {object} prevObj - The previous object to compare.\n * @param {object} nextObj - Object to compare with the previous one.\n * @param {WeakMap<object, unknown>} affected -\n * WeakMap that holds the tracking of which properties in the proxied object were accessed.\n * @param {WeakMap<object, unknown>} [cache] -\n * WeakMap that holds a cache of the comparisons for better performance with repetitive comparisons,\n * and to avoid infinite loop with circular structures.\n * @returns {boolean} - Boolean indicating if the affected property on the object has changed.\n *\n * @example\n * import { createProxy, isChanged } from 'proxy-compare';\n *\n * const obj = { a: \"1\", c: \"2\", d: { e: \"3\" } };\n * const affected = new WeakMap();\n *\n * const proxy = createProxy(obj, affected);\n *\n * proxy.a\n *\n * isChanged(obj, { a: \"1\" }, affected) // false\n *\n * proxy.a = \"2\"\n *\n * isChanged(obj, { a: \"1\" }, affected) // true\n */\n\nexport const isChanged = (\n  prevObj: unknown,\n  nextObj: unknown,\n  affected: WeakMap<object, unknown>,\n  cache?: WeakMap<object, unknown>,\n): boolean => {\n  if (Object.is(prevObj, nextObj)) {\n    return false;\n  }\n  if (!isObject(prevObj) || !isObject(nextObj)) return true;\n  const used = (affected as Affected).get(getOriginalObject(prevObj));\n  if (!used) return true;\n  if (cache) {\n    const hit = (cache as ChangedCache).get(prevObj);\n    if (hit && hit[NEXT_OBJECT_PROPERTY] === nextObj) {\n      return hit[CHANGED_PROPERTY];\n    }\n    // for object with cycles\n    (cache as ChangedCache).set(prevObj, {\n      [NEXT_OBJECT_PROPERTY]: nextObj,\n      [CHANGED_PROPERTY]: false,\n    });\n  }\n  let changed: boolean | null = null;\n  try {\n    for (const key of used[HAS_KEY_PROPERTY] || []) {\n      changed = Reflect.has(prevObj, key) !== Reflect.has(nextObj, key);\n      if (changed) return changed;\n    }\n    if (used[ALL_OWN_KEYS_PROPERTY] === true) {\n      changed = isAllOwnKeysChanged(prevObj, nextObj);\n      if (changed) return changed;\n    } else {\n      for (const key of used[HAS_OWN_KEY_PROPERTY] || []) {\n        const hasPrev = !!Reflect.getOwnPropertyDescriptor(prevObj, key);\n        const hasNext = !!Reflect.getOwnPropertyDescriptor(nextObj, key);\n        changed = hasPrev !== hasNext;\n        if (changed) return changed;\n      }\n    }\n    for (const key of used[KEYS_PROPERTY] || []) {\n      changed = isChanged(\n        (prevObj as any)[key],\n        (nextObj as any)[key],\n        affected,\n        cache,\n      );\n      if (changed) return changed;\n    }\n    if (changed === null) changed = true;\n    return changed;\n  } finally {\n    if (cache) {\n      cache.set(prevObj, {\n        [NEXT_OBJECT_PROPERTY]: nextObj,\n        [CHANGED_PROPERTY]: changed,\n      });\n    }\n  }\n};\n\n// explicitly track object with memo\nexport const trackMemo = (obj: unknown) => {\n  if (isObjectToTrack(obj)) {\n    return TRACK_MEMO_SYMBOL in obj;\n  }\n  return false;\n};\n\n/**\n * Unwrap proxy to get the original object.\n *\n * Used to retrieve the original object used to create the proxy instance with `createProxy`.\n *\n * @param {Proxy<object>} obj -  The proxy wrapper of the originial object.\n * @returns {object | null} - Return either the unwrapped object if exists.\n *\n * @example\n * import { createProxy, getUntracked } from 'proxy-compare';\n *\n * const original = { a: \"1\", c: \"2\", d: { e: \"3\" } };\n * const affected = new WeakMap();\n *\n * const proxy = createProxy(original, affected);\n * const originalFromProxy = getUntracked(proxy)\n *\n * Object.is(original, originalFromProxy) // true\n * isChanged(original, originalFromProxy, affected) // false\n */\nexport const getUntracked = <T>(obj: T): T | null => {\n  if (isObjectToTrack(obj)) {\n    return (obj as { [GET_ORIGINAL_SYMBOL]?: T })[GET_ORIGINAL_SYMBOL] || null;\n  }\n  return null;\n};\n\n/**\n * Mark object to be tracked.\n *\n * This function marks an object that will be passed into `createProxy`\n * as marked to track or not. By default only Array and Object are marked to track,\n * so this is useful for example to mark a class instance to track or to mark a object\n * to be untracked when creating your proxy.\n *\n * @param obj - Object to mark as tracked or not.\n * @param mark - Boolean indicating whether you want to track this object or not.\n * @returns - No return.\n *\n * @example\n * import { createProxy, markToTrack, isChanged } from 'proxy-compare';\n *\n * const nested = { e: \"3\" }\n *\n * markToTrack(nested, false)\n *\n * const original = { a: \"1\", c: \"2\", d: nested };\n * const affected = new WeakMap();\n *\n * const proxy = createProxy(original, affected);\n *\n * proxy.d.e\n *\n * isChanged(original, { d: { e: \"3\" } }, affected) // true\n */\nexport const markToTrack = (obj: object, mark = true) => {\n  objectsToTrack.set(obj, mark);\n};\n\n/**\n * Convert `affected` to path list\n *\n * `affected` is a weak map which is not printable.\n * This function is can convert it to printable path list.\n * It's for debugging purpose.\n *\n * @param obj - An object that is used with `createProxy`.\n * @param affected - A weak map that is used with `createProxy`.\n * @param onlyWithValues - An optional boolean to exclude object getters.\n * @returns - An array of paths.\n */\nexport const affectedToPathList = (\n  obj: unknown,\n  affected: WeakMap<object, unknown>,\n  onlyWithValues?: boolean,\n) => {\n  const list: (string | symbol)[][] = [];\n  const seen = new WeakSet();\n  const walk = (x: unknown, path?: (string | symbol)[]) => {\n    if (seen.has(x as object)) {\n      // for object with cycles\n      return;\n    }\n    if (isObject(x)) {\n      seen.add(x);\n    }\n    const used = isObject(x) && (affected as Affected).get(getOriginalObject(x));\n    if (used) {\n      used[HAS_KEY_PROPERTY]?.forEach((key) => {\n        const segment = `:has(${String(key)})`;\n        list.push(path ? [...path, segment] : [segment]);\n      });\n      if (used[ALL_OWN_KEYS_PROPERTY] === true) {\n        const segment = ':ownKeys';\n        list.push(path ? [...path, segment] : [segment]);\n      } else {\n        used[HAS_OWN_KEY_PROPERTY]?.forEach((key) => {\n          const segment = `:hasOwn(${String(key)})`;\n          list.push(path ? [...path, segment] : [segment]);\n        });\n      }\n      used[KEYS_PROPERTY]?.forEach((key) => {\n        if (!onlyWithValues || 'value' in (Object.getOwnPropertyDescriptor(x, key) || {})) {\n          walk((x as any)[key], path ? [...path, key] : [key]);\n        }\n      });\n    } else if (path) {\n      list.push(path);\n    }\n  };\n  walk(obj);\n  return list;\n};\n\n/**\n * replace newProxy function.\n *\n * This can be used if you want to use proxy-polyfill.\n * Note that proxy-polyfill can't polyfill everything.\n * Use it at your own risk.\n */\nexport const replaceNewProxy = (fn: typeof newProxy) => {\n  newProxy = fn;\n};\n"],"names":["TRACK_MEMO_SYMBOL","Symbol","GET_ORIGINAL_SYMBOL","AFFECTED_PROPERTY","ALL_OWN_KEYS_PROPERTY","newProxy","target","handler","Proxy","getProto","Object","getPrototypeOf","objectsToTrack","WeakMap","isObjectToTrack","obj","has","get","prototype","Array","isObject","x","copyTargetObject","isArray","from","descriptors","getOwnPropertyDescriptors","values","forEach","desc","configurable","create","getOriginalObject","createProxy","affected","proxyCache","targetCache","targetAndCopied","some","descriptor","writable","needsToCopyTargetObject","set","origObj","isTargetCopied","_state","state","trackObject","recordUsage","copiedTarget","handlerAndState","type","key","used","Set","add","Reflect","getOwnPropertyDescriptor","ownKeys","deleteProperty","onlyWithValues","list","seen","WeakSet","walk","path","_used$HAS_KEY_PROPERT","_used$KEYS_PROPERTY","segment","String","push","concat","_used$HAS_OWN_KEY_PRO","isChanged","prevObj","nextObj","cache","is","_cache$set","hit","changed","_step","_iterator","_createForOfIteratorHelperLoose","done","value","prevKeys","nextKeys","length","k","i","isAllOwnKeysChanged","_iterator2","_step2","_step3","_iterator3","_cache$set2","mark","fn"],"mappings":"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"}