{"version":3,"file":"state-ref.mjs","sources":["../src/lens/index.ts","../src/helper/index.ts","../src/connectors/collector.ts","../src/connectors/runner.ts","../src/proxy/index.ts","../src/core/ref.ts","../src/core/index.ts"],"sourcesContent":["/**\n * Type helper to extract nested property type\n */\ntype PropType<T, K extends keyof any> = K extends keyof T\n  ? T[K]\n  : K extends `${number}`\n  ? T extends readonly (infer U)[]\n    ? U\n    : any\n  : any;\n\n/**\n * The stateRef relies on data immutability to determine changes.\n * The lens pattern is used as a core part of the stateRef because,\n * it makes it easy to locate and safely change data.\n */\nexport function lens<T extends object>(\n  sceneList: (string | number | symbol)[] = []\n) {\n  return new Lens<T, T>(sceneList);\n}\n\nexport class Lens<Root extends object, Focus = Root> {\n  private sceneList: (string | number | symbol)[];\n  constructor(sceneList: (string | number | symbol)[]) {\n    this.sceneList = sceneList;\n  }\n  chain<K extends keyof Focus>(prop: K): Lens<Root, PropType<Focus, K>>;\n  chain<K extends string | number | symbol>(\n    prop: K\n  ): Lens<Root, PropType<Focus, K>>;\n  chain(prop: string | number | symbol): Lens<Root, any> {\n    return new Lens<Root, any>([...this.sceneList, prop]);\n  }\n  get(targetObject: Root): Focus {\n    return this.sceneList.reduce(\n      (currentObject: any, prop) => currentObject?.[prop],\n      targetObject\n    ) as Focus;\n  }\n  set(value: Focus) {\n    return (targetObject: Root): Root => this.copyOnWrite(targetObject, value);\n  }\n  private copyOnWrite(targetObject: Root, value: Focus): Root {\n    const copiedObject = this.shallowCopy(targetObject);\n\n    this.sceneList.reduce((currentObject: any, prop, index) => {\n      return (currentObject[prop] =\n        index === this.sceneList.length - 1\n          ? value\n          : this.shallowCopy(currentObject[prop]));\n    }, copiedObject);\n\n    return copiedObject;\n  }\n  private shallowCopy<T>(x: T): T {\n    if (Array.isArray(x)) {\n      return [...x] as T;\n    } else if (x && typeof x === 'object') {\n      return { ...x } as T;\n    }\n    return x;\n  }\n}\n","import type {\n  Copyable,\n  Watch,\n  StateRefStore,\n  Renew,\n  StateRefsTuple,\n  CombinedValue,\n} from '@/types';\nimport type { Lens } from '@/lens';\nimport { lens } from '@/lens';\n\nexport const DEFAULT_WATCH_OPTION = { cache: true, editable: true };\nexport const DEFAULT_CREATE_OPTION = { autoSync: true };\n\n/**\n * Map to assign a unique ID to each Symbol.\n * - WeakMap can't use symbol as key in TS, so we use Map.\n * - This ensures every Symbol in a path is uniquely identified.\n */\nconst symbolIdMap = new Map<symbol, number>();\nlet symbolCounter = 0;\n\n/**\n * Create information about the proxy that can be viewed in the developer console.\n */\nexport function makeDisplayProxyValue(\n  depthList: (string | number | symbol)[],\n  value: unknown\n) {\n  return {\n    _navi: keyFromDepthList(depthList),\n    _type: getType(value),\n    _value: '..',\n  };\n}\n\nfunction getType(value: unknown) {\n  if (value === null) {\n    return 'null';\n  } else if (Array.isArray(value)) {\n    return 'array';\n  } else if (typeof value === 'object') {\n    return 'object';\n  } else {\n    return typeof value;\n  }\n}\n\n/**\n * Escape special characters in strings to make keys bulletproof.\n * - Escapes ':', '|', and '\\' to prevent collisions in the final key string.\n */\nfunction escapeString(str: string): string {\n  return str.replace(/[:|\\\\]/g, '\\\\$&');\n}\n\n/**\n * Convert a path array into a unique, collision-resistant string key.\n * - Supports strings, numbers, and Symbols.\n * - Prefixes each element with a type marker:\n *   - 's:' for string\n *   - 'n:' for number\n *   - 'y:' for Symbol (unique ID via Map)\n * - Escapes special characters in strings.\n * - Joins all elements with '|' to form a flat key string.\n *\n * Example:\n *  [\"user\", Symbol(\"id\"), 42] -> \"s:user|y:1|n:42\"\n */\nexport function keyFromDepthList(path: (string | number | symbol)[]): string {\n  return path\n    .map(k => {\n      if (typeof k === 'string') return 's:' + escapeString(k);\n      if (typeof k === 'number') return 'n:' + k;\n      if (typeof k === 'symbol') {\n        if (!symbolIdMap.has(k)) symbolIdMap.set(k, ++symbolCounter);\n        return 'y:' + symbolIdMap.get(k);\n      }\n      return '?';\n    })\n    .join('|'); // safe separator\n}\n\n/**\n * We provide a convenience utility to make it easy to create data when \"copyOnWrite\" is required.\n */\nexport function copyable<T extends { [key: string | symbol]: unknown }>(\n  origObj: T,\n  lensInit?: Lens<T, any>\n): Copyable<T> {\n  let lensIns = lensInit || lens<T>();\n\n  return new Proxy(origObj as unknown as Copyable<T>, {\n    get(target: Copyable<T>, prop: keyof T | 'writeCopy') {\n      if (prop === 'writeCopy') {\n        return <V>(value: V) => {\n          return lensIns.set(value)(target as unknown as T);\n        };\n      }\n\n      return copyable(origObj, lensIns.chain(prop as keyof T));\n    },\n    set() {\n      throw new Error(\n        'Property modification is not supported on a copyable object. Use \"writeCopy\" for state updates.'\n      );\n    },\n  });\n}\n\n/**\n * Provides a convenience utility to make deep copying easier in special cases.\n */\nexport function cloneDeep<T>(value: T): T {\n  if (value == null) {\n    return value;\n  }\n\n  if (typeof value !== 'object') {\n    return value;\n  }\n\n  const isArray = Array.isArray(value);\n  const Ctor = isArray ? Array : Object;\n\n  const result = new Ctor() as T; // 새로운 객체 또는 배열 생성\n\n  for (const key in value) {\n    if (Object.prototype.hasOwnProperty.call(value, key)) {\n      result[key] = cloneDeep(value[key]); // 재귀적으로 깊은 복사\n    }\n  }\n\n  return result;\n}\n/**\n * Combines multiple state watchers to produce a derived (computed) value,\n * and invokes the provided callback whenever the computed value changes.\n */\nexport function createComputed<W extends readonly Watch<any>[], R>(\n  watches: W,\n  callback: (a: StateRefsTuple<W>) => R\n) {\n  let result: R;\n  const proxy: { value: R } = {\n    get value(): R {\n      return result;\n    },\n    set value(_setter) {\n      console.warn('Can not setting');\n    },\n  };\n\n  return (\n    computedCallback?: (proxy: { value: R }, isFirst: boolean) => void\n  ) => {\n    const refs = watches.map(watch => watch(() => false)) as StateRefsTuple<W>;\n\n    watches.forEach((watch, index) => {\n      watch((ref, init) => {\n        (refs as any)[index] = ref;\n        result = callback(refs);\n        if (!init && computedCallback) {\n          computedCallback(proxy, false);\n        }\n      });\n    });\n\n    if (computedCallback) {\n      computedCallback(proxy, true);\n    }\n\n    return proxy;\n  };\n}\n\n/**\n * Observes multiple Watch instances together and triggers a callback\n * whenever any of them changes. The callback receives the current\n * StateRefStore values of all watches and a boolean indicating\n * whether this is the first invocation.\n */\nexport function combineWatch<W extends readonly Watch<any>[]>(\n  watches: [...W]\n): Watch<CombinedValue<W>> {\n  type R = CombinedValue<W>;\n  type RefsTuple = StateRefsTuple<W>;\n\n  return (\n    callback?: Renew<StateRefStore<R>>,\n    userOption?: { cache?: boolean }\n  ): StateRefStore<R> => {\n    const refs: RefsTuple = watches.map(w =>\n      w(() => {}, userOption)\n    ) as RefsTuple;\n\n    const combinedStore: StateRefStore<R> = new Proxy({} as StateRefStore<R>, {\n      get(_, prop) {\n        if (prop === 'value') {\n          console.warn(\n            `You cannot directly access the nested 'value' of a store created by combineWatch.`\n          );\n\n          return refs.map(s => s.value) as R;\n        }\n\n        return Reflect.get(refs, prop);\n      },\n      set(_, prop) {\n        if (prop === 'value') {\n          console.warn(\n            \"You cannot directly assign to '.value' of a store created by combineWatch. Use an individual store instead (e.g., store[0].value).\"\n          );\n        } else {\n          console.warn(\n            `You cannot directly assign to the property '${String(\n              prop\n            )}' of a store created by combineWatch.`\n          );\n        }\n        return false;\n      },\n    });\n\n    watches.forEach((watch, i) => {\n      const index = i as keyof RefsTuple;\n      watch((ref, isFirst) => {\n        refs[index] = ref as RefsTuple[number];\n\n        if (!isFirst && callback) {\n          callback(combinedStore, false);\n        }\n      }, userOption);\n    });\n\n    if (callback) {\n      callback(combinedStore, true);\n    }\n\n    return combinedStore;\n  };\n}\n","import type { Run, RunInfo, StoreRenderList } from '@/types';\nimport { keyFromDepthList } from '@/helper';\n\n/**\n * The subscription to store starts the moment the user of stateRef fetches the reference as a “.value”.\n * This code captures the moment of fetching to “.value” and collects the subscription.\n */\nexport function collector(\n  value: unknown,\n  getNextValue: () => unknown,\n  newDepthList: (string | number | symbol)[],\n  run: Run,\n  storeRenderList: StoreRenderList<any>\n) {\n  if (run) {\n    const key = keyFromDepthList(newDepthList);\n\n    const runInfo: RunInfo<unknown> = {\n      value,\n      getNextValue,\n      key,\n    };\n\n    if (storeRenderList.has(run)) {\n      const subList = storeRenderList.get(run)!;\n      if (!subList.has(key)) subList.set(key, runInfo);\n    } else {\n      const subList = new Map<string, RunInfo<unknown>>();\n      subList.set(key, runInfo);\n      storeRenderList.set(run, subList);\n    }\n  }\n}\n","import type { Run, Renew, StateRefStore, StoreRenderList } from '@/types';\n\n/**\n * Based on the information gathered by the “collector”,\n * this code identifies and executes a callback function for store changes.\n */\nexport function runner(storeRenderList: StoreRenderList<any>) {\n  const runableRenewList: Set<Run> = new Set();\n\n  storeRenderList.forEach((defs, run) => {\n    defs.forEach((item, key) => {\n      const { value, getNextValue } = item;\n      try {\n        const nextValue = getNextValue();\n\n        if (value !== nextValue) {\n          runableRenewList.add(run);\n          item.value = nextValue;\n        }\n      } catch (error) {\n        /**\n         * The subscribe function is subscribing to a value that has already been removed,\n         * so when run is executed, either the user has handled the exception with optional chaining or similar,\n         * or an error will occur. Therefore, it’s fine not to throw an error at this point.\n         */\n        console.warn(\n          `Value for key ${key} has been removed, skipping update:`,\n          error\n        );\n      }\n    });\n  });\n\n  runableRenewList.forEach(run => {\n    if (run && run() === false) {\n      storeRenderList.delete(run);\n    }\n  });\n  runableRenewList.clear();\n}\n\nexport function firstRunner<V>(\n  run: Run,\n  storeRenderList: StoreRenderList<any>,\n  cacheMap: WeakMap<Renew<StateRefStore<V>>, StateRefStore<V>>,\n  renew: Renew<StateRefStore<V>>\n) {\n  const renewResult = run!(true);\n\n  if (renewResult instanceof AbortSignal) {\n    renewResult.addEventListener('abort', () => {\n      cacheMap.delete(renew);\n      storeRenderList.delete(run);\n    });\n  }\n}\n","import { lens } from '@/lens';\nimport type { Lens } from '@/lens';\nimport { makeDisplayProxyValue } from '@/helper';\nimport { collector } from '@/connectors/collector';\nimport { runner } from '@/connectors/runner';\nimport type { Run, WithRoot, StoreRenderList } from '@/types';\n\n/**\n * Use proxies to secure values and match them to lens.\n */\nexport function makeProxy<S extends WithRoot, T extends object>(\n  value: unknown,\n  storeRenderList: StoreRenderList<any>,\n  run: Run,\n  autoSync: boolean,\n  editable: boolean,\n  rootValue: S,\n  lensValue: Lens<S, any> = lens<S>(),\n  depth: number = 0,\n  depthList: (string | number | symbol)[] = []\n): T {\n  const result = new Proxy(\n    makeDisplayProxyValue(depthList, value) as unknown as T,\n    {\n      /**\n       * 1. When accessing \".value\" from a proxy\n       *   1-1. Have the \"collector\" collect the subscription callbacks and the\n       *   1-2. Subtracts a value from \"lens\" and returns it\n       * 2. When accessing iterables from a proxy.\n       * 3. When accessing child object types from a proxy\n       */\n      get(_: T, prop: keyof T & (string | symbol)) {\n        const newDepthList = [...depthList, prop];\n\n        /**\n         * When accessing \".value\" from a proxy\n         */\n        if (prop === 'value') {\n          const currentValue = lensValue.get(rootValue);\n\n          collector(\n            currentValue,\n            () => lensValue.get(rootValue),\n            [...depthList],\n            run,\n            storeRenderList\n          );\n\n          return currentValue;\n        }\n\n        /**\n         * When accessing \"iterator\" from a proxy\n         */\n        if (prop === Symbol.iterator) {\n          return function* () {\n            const iterableValue = lensValue.get(rootValue);\n            if (\n              !iterableValue ||\n              typeof (iterableValue as any)[Symbol.iterator] !== 'function'\n            ) {\n              return;\n            }\n            for (const [index, itemValue] of (\n              iterableValue as unknown as any[]\n            ).entries()) {\n              yield makeProxy(\n                itemValue,\n                storeRenderList,\n                run,\n                autoSync,\n                editable,\n                rootValue,\n                lensValue.chain(index),\n                depth + 1,\n                [...depthList, String(index)]\n              );\n            }\n          };\n        }\n\n        /**\n         * When accessing child object types from a proxy\n         */\n        const lens = lensValue.chain(prop);\n        const propertyValue = lens.get(rootValue);\n\n        return makeProxy(\n          propertyValue,\n          storeRenderList,\n          run,\n          autoSync,\n          editable,\n          rootValue,\n          lens,\n          depth + 1,\n          newDepthList\n        );\n      },\n\n      /**\n       * When assigning a value to “.value”, copyOnWrite is performed.\n       * Error if you try to assign a value to something that isn't a \".value\".\n       * ex) ref.a.b = 'newValue'; // Error\n       * ex) ref.a.b.value = 'newValue'; // Success\n       */\n      set(_, prop: string | symbol, value) {\n        if (prop !== 'value') {\n          throw new Error('Can only be assigned to a \"value\".');\n        } else if (prop === 'value' && !editable) {\n          throw new Error(\n            'With the current settings, direct modification is not allowed.'\n          );\n        } else if (prop === 'value' && value !== lensValue.get(rootValue)) {\n          const newTree = lensValue.set(value)(rootValue);\n          rootValue.root = newTree.root;\n\n          /**\n           * Run dependency subscription callbacks.\n           */\n          if (autoSync) {\n            runner(storeRenderList);\n          }\n        }\n        return true;\n      },\n    }\n  );\n\n  return result;\n}\n","import { makeProxy } from '@/proxy';\nimport { firstRunner } from '@/connectors/runner';\n\nimport type { Renew, StoreType, StateRefStore, StoreRenderList } from '@/types';\n\n/**\n * Make the value a stateRef.\n */\nexport function makeReference<V>({\n  renew,\n  rootValue,\n  storeRenderList,\n  cacheMap,\n  autoSync,\n  editable,\n}: {\n  renew: Renew<StateRefStore<V>>;\n  rootValue: StoreType<V>;\n  storeRenderList: StoreRenderList<any>;\n  cacheMap: WeakMap<Renew<StateRefStore<V>>, StateRefStore<V>>;\n  autoSync: boolean;\n  editable: boolean;\n}) {\n  const ref: { value: null | StateRefStore<StoreType<V>> } = {\n    value: null,\n  };\n  const run = (isFirst?: boolean) => renew(ref.value!.root, isFirst ?? false);\n\n  ref.value = makeProxy<StoreType<V>, StateRefStore<StoreType<V>>>(\n    rootValue,\n    storeRenderList,\n    run,\n    autoSync,\n    editable,\n    rootValue\n  );\n\n  /**\n   * It is initialized only once per subscription and collects the 'abort' signal.\n   */\n  firstRunner(run, storeRenderList, cacheMap, renew);\n\n  cacheMap.set(renew, ref.value!.root);\n\n  return ref.value!.root;\n}\n","import { DEFAULT_WATCH_OPTION, DEFAULT_CREATE_OPTION } from '@/helper';\nimport { makeReference } from '@/core/ref';\nimport { runner } from '@/connectors/runner';\n\nimport type {\n  Renew,\n  StoreType,\n  StateRefStore,\n  StoreRenderList,\n  ManualSyncStore,\n} from '@/types';\n\n/**\n * createStore - The argument is the initial value of the state\n *\n * Can work with primitive types, or you can work with object types.\n * The return value is the \"watch\" function.\n *\n * example>\n * const watch = createStore<number>(7)\n * // const watch = createStore<{name: string; age: number;}>({ name: 'brown', age: 38 })\n * const stateRef = watch(stateRef => {\n *   console.log(stateRef.value));\n * });\n */\nexport function createStore<V>(orignalValue: V) {\n  const { watch } = create(orignalValue, { autoSync: true });\n\n  return watch;\n}\nexport function createStoreManualSync<V>(orignalValue: V): ManualSyncStore<V> {\n  return create(orignalValue, { autoSync: false });\n}\n\nfunction create<V>(orignalValue: V, userCreateOption?: { autoSync?: boolean }) {\n  const storeRenderList: StoreRenderList<any> = new Map();\n  const cacheMap = new WeakMap<Renew<StateRefStore<V>>, StateRefStore<V>>();\n  const { autoSync } = Object.assign(\n    {},\n    DEFAULT_CREATE_OPTION,\n    userCreateOption || {}\n  );\n  const rootValue: StoreType<V> = { root: orignalValue };\n\n  const watch = (\n    renew: Renew<StateRefStore<V>> = () => {},\n    userOption?: { cache?: boolean; editable?: boolean }\n  ): StateRefStore<V> => {\n    const watchOption = Object.assign(\n      {},\n      DEFAULT_WATCH_OPTION,\n      userOption || { editable: autoSync }\n    );\n    const { cache, editable } = watchOption;\n\n    /**\n     * Caching\n     */\n    if (cache && renew && cacheMap.has(renew)) {\n      return cacheMap.get(renew)!;\n    }\n\n    /**\n     * Make the value a stateRef.\n     */\n    return makeReference({\n      renew,\n      rootValue,\n      storeRenderList,\n      cacheMap,\n      autoSync,\n      editable,\n    });\n  };\n\n  return {\n    watch,\n    updateRef: watch(() => {}, { editable: true }),\n    sync: () => {\n      runner(storeRenderList);\n    },\n  };\n}\n"],"names":["lens","sceneList","Lens","__publicField","prop","targetObject","currentObject","value","copiedObject","index","x","DEFAULT_WATCH_OPTION","DEFAULT_CREATE_OPTION","symbolIdMap","symbolCounter","makeDisplayProxyValue","depthList","keyFromDepthList","getType","escapeString","str","path","k","copyable","origObj","lensInit","lensIns","target","cloneDeep","Ctor","result","key","createComputed","watches","callback","proxy","_setter","computedCallback","refs","watch","ref","init","combineWatch","userOption","w","combinedStore","_","s","isFirst","collector","getNextValue","newDepthList","run","storeRenderList","runInfo","subList","runner","runableRenewList","defs","item","nextValue","error","firstRunner","cacheMap","renew","renewResult","makeProxy","autoSync","editable","rootValue","lensValue","depth","currentValue","iterableValue","itemValue","propertyValue","newTree","makeReference","createStore","orignalValue","create","createStoreManualSync","userCreateOption","watchOption","cache"],"mappings":"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"}