{"version":3,"file":"index.mjs","names":["getProps: (target: Target, name: string) => Props","target: Target","name?: string","name","compareFn?: (a: T, b: T) => number","start: number","deleteCount: number","i: number","value: T","thing: any","name?: string","name","variants: ReadonlyArray<T>","options: string | EnumAtomOptions<T, Format>","enumAtom: typeof stateAtom","ctx: Ctx","update: any","initState: Map<Key, Value> | FirstMapConstructorParam<Key, Value>","name?: string","name","key: Key","value: Value","ctx: Ctx","creator: () => Value","anAtom: T","state: LinkedList<Node>","node: Node | Omit<Node, keyof LLNode>","after: null | Node","node: Node","a: Node","b: Node","head: null | LLNode<T>","prev?: Array<LLNode<T>>","arr: Array<LLNode<T>>","options:\n    | Array<Node>\n    | ((ctx: Ctx, ...params: Params) => Node)\n    | {\n      create?: (ctx: Ctx, ...params: Params) => Node\n      initState?: Array<Node>\n      key?: Key\n    }\n    | {\n      create: (ctx: Ctx, ...params: Params) => Node\n      initSnapshot?: Array<Params>\n      key?: Key\n    }","ctx: Ctx","STATE: null | LinkedList<LLNode<Node>>","ctxOrInitState: Ctx | Node[]","initSnapshot?: Params[]","cb: Fn<[Ctx], T>","node: LLNode<Node>","a: LLNode<Node>","b: LLNode<Node>","after: null | LLNode<Node>","cb: (node: LLNode<Node>) => boolean","array: LinkedListAtom<Params, Node, Key>['array']","state: Array<LLNode<Node>>","reatomMap","cb: (ctx: Ctx, node: LLNode<Node>) => T","options:\n      | string\n      | {\n          name?: string\n          onCreate?: (ctx: Ctx, node: LLNode<T>) => void\n          onRemove?: (ctx: Ctx, node: LLNode<T>, origin: LLNode<Node>) => void\n          onSwap?: (ctx: Ctx, payload: { a: LLNode<T>; b: LLNode<T> }) => void\n          onMove?: (ctx: Ctx, node: LLNode<T>) => void\n          onClear?: (\n            ctx: Ctx,\n            lastState: LinkedListDerivedState<LLNode<Node>, LLNode<T>>,\n          ) => void\n        }","options","mapList?: State","mapList","kind: never","name","array: LinkedListDerivedAtom<LLNode<Node>, LLNode<T>>['array']","state: Array<LLNode<T>>","thing: any","name?: string","name","initState: T","name?: string","slice: Partial<T>","initState: Set<T> | FirstSetConstructorParam<T>","name?: string","name","ctx: Ctx","el: T","set: Set<T>","thing: any","reatomString: {\n  (init?: string, name?: string): StringAtom\n  <T extends string>(init: T, name?: string): StringAtom<T>\n}","name?: string","name","computed: (ctx: CtxSpy, state: AtomState<T>) => AtomState<T>","anAtom: T","reducers: R","anAtom: A","anAtom"],"sources":["../src/withAssign.ts","../src/reatomArray.ts","../src/reatomBoolean.ts","../src/reatomEnum.ts","../src/reatomMap.ts","../src/reatomLinkedList.ts","../src/reatomNumber.ts","../src/reatomRecord.ts","../src/reatomSet.ts","../src/reatomString.ts","../src/withComputed.ts","../src/withReducers.ts"],"sourcesContent":["import { Atom, __count } from '@reatom/core'\nimport { assign } from '@reatom/utils'\n\nexport const withAssign =\n  <Target extends Atom, Props extends object>(\n    getProps: (target: Target, name: string) => Props,\n  ) =>\n  (target: Target) =>\n    assign(target, getProps(target, target.__reatom.name!)) as Target & Props\n","import { Action, AtomMut, action, atom } from '@reatom/core'\nimport { withAssign } from './withAssign'\n\nexport interface ArrayLikeAtom<T = any> extends AtomMut<Array<T>> {\n  __reatomArray: true\n}\n\nexport interface ArrayAtom<T> extends ArrayLikeAtom<T> {\n  toReversed: Action<[], T[]>\n  toSorted: Action<[compareFn?: (a: T, b: T) => number], T[]>\n  toSpliced: Action<[start: number, deleteCount: number, ...items: T[]], T[]>\n  with: Action<[i: number, value: T], T[]>\n  push: Action<[...items: T[]], number>\n  pop: Action<[], T | undefined>\n  shift: Action<[], T | undefined>\n  unshift: Action<[...items: T[]], number>\n}\n\nexport const reatomArray = <T>(\n  initState = [] as T[],\n  name?: string,\n): ArrayAtom<T> =>\n  atom(initState, name).pipe(\n    withAssign((target, name) => ({\n      __reatomArray: true as const,\n      \n      toReversed: action(\n        (ctx) => target(ctx, (prev) => prev.slice().reverse()),\n        `${name}.toReversed`,\n      ),\n      toSorted: action(\n        (ctx, compareFn?: (a: T, b: T) => number) =>\n          target(ctx, (prev) => prev.slice().sort(compareFn)),\n        `${name}.toSorted`,\n      ),\n      toSpliced: action(\n        (ctx, start: number, deleteCount: number, ...items: T[]) =>\n          target(ctx, (state) => {\n            state = state.slice()\n            state.splice(start, deleteCount, ...items)\n            return state\n          }),\n        `${name}.toSpliced`,\n      ),\n      with: action(\n        (ctx, i: number, value: T) =>\n          target(ctx, (state) => {\n            if (Object.is(state.at(i), value)) return state\n            state = state.slice()\n            state[i] = value\n            return state\n          }),\n        `${name}.with`,\n      ),\n      push: action((ctx, ...items: T[]) => {\n        const arrCopy = ctx.get(target).slice()\n        const pushed = arrCopy.push(...items)\n        target(ctx, arrCopy)\n\n        return pushed\n      }, `${name}.push`),\n      pop: action((ctx) => {\n        const arrCopy = ctx.get(target).slice()\n        const popped = arrCopy.pop()\n        target(ctx, arrCopy)\n\n        return popped\n      }, `${name}.pop`),\n      shift: action((ctx) => {\n        const arrCopy = ctx.get(target).slice()\n        const shifted = arrCopy.shift()\n        target(ctx, arrCopy)\n\n        return shifted\n      }, `${name}.shift`),\n      unshift: action((ctx, ...items: T[]) => {\n        const arrCopy = ctx.get(target).slice()\n        const unshifted = arrCopy.unshift(...items)\n        target(ctx, arrCopy)\n\n        return unshifted\n      }, `${name}.unshift`),\n    })),\n  )\n\nexport const isArrayAtom = (thing: any): thing is ArrayLikeAtom => thing?.__reatomArray === true\n","import { Action, AtomMut, action, atom } from '@reatom/core'\nimport { withAssign } from './withAssign'\n\nexport interface BooleanAtom extends AtomMut<boolean> {\n  toggle: Action<[], boolean>\n  setTrue: Action<[], true>\n  setFalse: Action<[], false>\n  reset: Action<[], boolean>\n}\n\nexport const reatomBoolean = (init = false, name?: string): BooleanAtom =>\n  atom(init, name).pipe(\n    withAssign((target, name) => ({\n      toggle: action((ctx) => target(ctx, (prev) => !prev), `${name}.toggle`),\n      setTrue: action((ctx) => target(ctx, true) as true, `${name}.setTrue`),\n      setFalse: action(\n        (ctx) => target(ctx, false) as false,\n        `${name}.setFalse`,\n      ),\n      reset: action((ctx) => target(ctx, init), `${name}.reset`),\n    })),\n  )\n","import {\n  action,\n  Action,\n  atom,\n  AtomMut,\n  Ctx,\n  throwReatomError,\n} from '@reatom/core'\n\nexport type EnumFormat = 'camelCase' | 'snake_case'\n\nexport type EnumAtom<\n  T extends string,\n  Format extends EnumFormat = 'camelCase',\n> = AtomMut<T> & {\n  [Variant in T as Format extends 'camelCase'\n    ? `set${Capitalize<Variant>}`\n    : Format extends 'snake_case'\n      ? `set_${Variant}`\n      : never]: Action<[], Variant>\n} & {\n  reset: Action<[], T>\n  enum: { [K in T]: K }\n}\n\nexport type EnumAtomOptions<\n  T extends string,\n  Format extends EnumFormat = 'camelCase',\n> = {\n  name?: string\n  format?: Format\n  initState?: T\n}\n\nexport const reatomEnum = <\n  const T extends string,\n  Format extends 'camelCase' | 'snake_case' = 'camelCase',\n>(\n  variants: ReadonlyArray<T>,\n  options: string | EnumAtomOptions<T, Format> = {},\n) => {\n  const {\n    name,\n    format = 'camelCase' as Format,\n    initState = variants[0],\n  }: EnumAtomOptions<T, Format> = typeof options === 'string'\n    ? { name: options }\n    : options\n\n  const stateAtom = atom(initState, name) as EnumAtom<T, Format>\n  const enumAtom: typeof stateAtom = Object.assign((ctx: Ctx, update: any) => {\n    const state = stateAtom(ctx, update)\n    throwReatomError(\n      !variants.includes(state),\n      `invalid enum value \"${state}\" for \"${name}\" enum`,\n    )\n    return state\n  }, stateAtom)\n  const cases = (enumAtom.enum = {} as { [K in T]: K })\n\n  enumAtom.reset = action((ctx) => enumAtom(ctx, initState!), `${name}.reset`)\n\n  for (const variant of variants) {\n    cases[variant] = variant\n    const setterName = variant.replace(\n      /^./,\n      (firstLetter) =>\n        'set' +\n        (format === 'camelCase'\n          ? firstLetter.toUpperCase()\n          : `_${firstLetter}`),\n    )\n\n    ;(enumAtom as any)[setterName] = action(\n      (ctx) => enumAtom(ctx, variant)!,\n      `${name}.${setterName}`,\n    )\n  }\n\n  return enumAtom as EnumAtom<T, Format>\n}\n","import { Action, action, Atom, atom, AtomMut, Ctx } from '@reatom/core'\nimport { withAssign } from './withAssign'\n\nexport interface MapAtom<Key, Value> extends AtomMut<Map<Key, Value>> {\n  get: (ctx: Ctx, key: Key) => Value | undefined\n  getOrCreate: (ctx: Ctx, key: Key, creator: () => Value) => Value\n  has: (ctx: Ctx, key: Key) => boolean\n  set: Action<[key: Key, value: Value], Map<Key, Value>>\n  delete: Action<[key: Key], Map<Key, Value>>\n  clear: Action<[], Map<Key, Value>>\n  reset: Action<[], Map<Key, Value>>\n  sizeAtom: Atom<number>\n}\n\ntype FirstMapConstructorParam<Key, Value> = ConstructorParameters<typeof Map<Key, Value>>[0]\n\nexport const reatomMap = <Key, Value>(\n  initState: Map<Key, Value> | FirstMapConstructorParam<Key, Value> = new Map<Key, Value>(),\n  name?: string,\n): MapAtom<Key, Value> => {\n  const atomInitState = initState instanceof Map ? initState : new Map(initState);\n\n  return atom(atomInitState, name).pipe(\n    withAssign((target, name) => {\n      const getOrCreate = action((ctx, key: Key, value: Value) => {\n        actions.set(ctx, key, value)\n        return value\n      }, `${name}.getOrCreate`)\n\n      const actions = {\n        get: (ctx: Ctx, key: Key) => ctx.get(target).get(key),\n        getOrCreate: (ctx: Ctx, key: Key, creator: () => Value) =>\n          actions.has(ctx, key)\n            ? actions.get(ctx, key)!\n            : getOrCreate(ctx, key, creator()),\n        has: (ctx: Ctx, key: Key) => ctx.get(target).has(key),\n        set: action(\n          (ctx, key: Key, value: Value) =>\n            target(ctx, (prev) => {\n              const valuePrev = prev.get(key)\n              return Object.is(valuePrev, value) &&\n                (value !== undefined || prev.has(key))\n                ? prev\n                : new Map(prev).set(key, value)\n            }),\n          `${name}.set`,\n        ),\n        delete: action(\n          (ctx, key: Key) =>\n            target(ctx, (prev) => {\n              if (!prev.has(key)) return prev\n              const next = new Map(prev)\n              next.delete(key)\n              return next\n            }),\n          `${name}.delete`,\n        ),\n        clear: action((ctx) => target(ctx, new Map()), `${name}.clear`),\n        reset: action((ctx) => target(ctx, atomInitState), `${name}.reset`),\n        sizeAtom: atom(ctx =>  ctx.spy(target).size, `${name}.size`),\n      }\n\n      return actions\n    }),\n  )\n}\n","import {\n  type Atom,\n  type Action,\n  type Ctx,\n  type Rec,\n  atom,\n  action,\n  type Fn,\n  throwReatomError,\n  __count,\n  isAtom,\n} from '@reatom/core'\nimport { isObject } from '@reatom/utils'\n\ntype State<T> = T extends Atom<infer Value> ? Value : T\n\nconst readonly = <T extends Atom>(\n  anAtom: T,\n): {\n  [K in keyof T]: T[K]\n} => ({\n  ...anAtom,\n})\n\nexport const LL_PREV = Symbol('Reatom linked list prev')\nexport const LL_NEXT = Symbol('Reatom linked list next')\n\n/** Linked List is reusing the model reference to simplify the reference sharing and using it as a key of LL methods.\n * Btw, symbols works fine with serialization and will not add a garbage to an output.\n */\nexport type LLNode<T extends Rec = Rec> = T & {\n  [LL_PREV]: null | LLNode<T>\n  [LL_NEXT]: null | LLNode<T>\n}\n\ntype LLChanges<Node extends LLNode> =\n  | { kind: 'create'; node: Node }\n  | { kind: 'remove'; node: Node }\n  | { kind: 'swap'; a: Node; b: Node }\n  | { kind: 'move'; node: Node; after: null | Node }\n  | { kind: 'clear' }\n\nexport interface LinkedList<Node extends LLNode = LLNode> {\n  head: null | Node\n  tail: null | Node\n  size: number\n  version: number\n  changes: Array<LLChanges<Node>>\n}\n\nexport interface LinkedListLikeAtom<T extends LinkedList = LinkedList>\n  extends Atom<T> {\n  __reatomLinkedList: true\n\n  array: Atom<Array<T extends LinkedList<infer LLNode> ? LLNode : never>>\n}\n\nexport interface LinkedListAtom<\n  Params extends any[] = any[],\n  Node extends Rec = Rec,\n  Key extends keyof Node = never,\n> extends LinkedListLikeAtom<LinkedList<LLNode<Node>>> {\n  batch: Action<[cb: Fn]>\n\n  create: Action<Params, LLNode<Node>>\n  remove: Action<[LLNode<Node>], boolean>\n  swap: Action<[a: LLNode<Node>, b: LLNode<Node>], void>\n  move: Action<[node: LLNode<Node>, after: null | LLNode<Node>], void>\n  clear: Action<[], void>\n\n  find: (ctx: Ctx, cb: (node: LLNode<Node>) => boolean) => null | LLNode<Node>\n\n  /** This lazy map is useful for working with serializable identifier,\n   * but it is not recommended to use it for large (thousands elements) lists */\n  map: Key extends never ? never : Atom<Map<State<Node[Key]>, LLNode<Node>>>\n\n  initiate: {\n    (initState: Array<Node>): LinkedList<LLNode<Node>>\n    (ctx: Ctx, initSnapshot: Array<Params>): LinkedList<LLNode<Node>>\n  }\n\n  reatomMap: <T extends Rec>(\n    cb: (ctx: Ctx, node: LLNode<Node>) => T,\n    options?:\n      | string\n      | {\n          name?: string\n          onCreate?: (ctx: Ctx, node: LLNode<T>) => void\n          onRemove?: (ctx: Ctx, node: LLNode<T>, origin: LLNode<Node>) => void\n          onSwap?: (ctx: Ctx, payload: { a: LLNode<T>; b: LLNode<T> }) => void\n          onMove?: (ctx: Ctx, node: LLNode<T>) => void\n          onClear?: (\n            ctx: Ctx,\n            lastState: LinkedListDerivedState<LLNode<Node>, LLNode<T>>,\n          ) => void\n        },\n  ) => LinkedListDerivedAtom<LLNode<Node>, LLNode<T>>\n\n  // reatomFilter: (\n  //   cb: (ctx: CtxSpy, node: Node) => any,\n  //   name?: string,\n  // ) => Atom<ListType<Node>>\n\n  // reatomReduce: <T>(\n  //   options: {\n  //     init: T\n  //     add: (ctx: CtxSpy, acc: T, node: LLNode<Node>) => T\n  //     del: (ctx: Ctx, acc: T, node: LLNode<Node>) => T\n  //   },\n  //   name?: string,\n  // ) => Atom<T>\n}\n\n// TODO rename to `DerivedLinkedList`\nexport interface LinkedListDerivedState<Node extends LLNode, T extends LLNode>\n  extends LinkedList<T> {\n  map: WeakMap<Node, T>\n}\n\nexport interface LinkedListDerivedAtom<Node extends LLNode, T extends LLNode>\n  extends LinkedListLikeAtom<LinkedListDerivedState<Node, T>> {}\n\nconst addLL = <Node extends LLNode>(\n  state: LinkedList<Node>,\n  node: Node | Omit<Node, keyof LLNode>,\n  after: null | Node,\n) => {\n  if (node === after) return\n\n  if (after) {\n    // updateLL(node as Node, after, after[LL_PREV])\n    ;(node as Node)[LL_PREV] = after\n    ;(node as Node)[LL_NEXT] = after[LL_NEXT]\n    after[LL_NEXT] = node as Node\n    if (state.tail === after) {\n      state.tail = node as Node\n    }\n  } else {\n    ;(node as Node)[LL_PREV] = null\n    ;(node as Node)[LL_NEXT] = state.head\n    if (state.head) {\n      state.head[LL_PREV] = node as Node\n    }\n    if (!state.tail) {\n      state.tail = node as Node\n    }\n    state.head = node as Node\n  }\n  state.size++\n}\n\nconst removeLL = <Node extends LLNode>(state: LinkedList<Node>, node: Node) => {\n  if (state.head === node) {\n    state.head = node[LL_NEXT] as Node\n  } else if (node[LL_PREV] !== null) {\n    node[LL_PREV][LL_NEXT] = node[LL_NEXT]\n  }\n\n  if (state.tail === node) {\n    state.tail = node[LL_PREV] as Node\n  } else if (node[LL_NEXT] !== null) {\n    node[LL_NEXT][LL_PREV] = node[LL_PREV]\n  }\n\n  node[LL_PREV] = null\n  node[LL_NEXT] = null\n\n  state.size--\n}\n\nconst swapLL = <Node extends LLNode>(\n  state: LinkedList<Node>,\n  a: Node,\n  b: Node,\n): void => {\n  if (a === b) return\n\n  // If b is the head, swap a and b to make a the head\n  if (state.head === b) return swapLL(state, b, a)\n\n  const prevA = a[LL_PREV]\n  const nextA = a[LL_NEXT]\n  const prevB = b[LL_PREV]\n  const nextB = b[LL_NEXT]\n\n  // Check if they are adjacent\n  if (nextA === b) {\n    // a is before b\n    a[LL_NEXT] = nextB\n    b[LL_PREV] = prevA\n    b[LL_NEXT] = a\n    a[LL_PREV] = b\n\n    if (nextB) nextB[LL_PREV] = a\n    if (prevA) prevA[LL_NEXT] = b\n  } else if (nextB === a) {\n    // b is before a\n    b[LL_NEXT] = nextA\n    a[LL_PREV] = prevB\n    a[LL_NEXT] = b\n    b[LL_PREV] = a\n\n    if (nextA) nextA[LL_PREV] = b\n    if (prevB) prevB[LL_NEXT] = a\n  } else {\n    // Non-adjacent nodes, just swap them\n    if (prevA) prevA[LL_NEXT] = b\n    if (nextA) nextA[LL_PREV] = b\n    if (prevB) prevB[LL_NEXT] = a\n    if (nextB) nextB[LL_PREV] = a\n\n    a[LL_PREV] = prevB\n    a[LL_NEXT] = nextB\n    b[LL_PREV] = prevA\n    b[LL_NEXT] = nextA\n  }\n\n  // Update head and tail pointers if necessary\n  if (state.head === a) {\n    state.head = b\n  } else if (state.head === b) {\n    state.head = a\n  }\n\n  if (state.tail === a) {\n    state.tail = b\n  } else if (state.tail === b) {\n    state.tail = a\n  }\n}\n\nconst moveLL = <Node extends LLNode>(\n  state: LinkedList<Node>,\n  node: Node,\n  after: null | Node,\n) => {\n  removeLL(state, node)\n  addLL(state, node, after)\n}\n\nconst clearLL = <Node extends LLNode>(state: LinkedList<Node>) => {\n  while (state.tail) removeLL(state, state.tail)\n}\n\nconst toArray = <T extends Rec>(\n  head: null | LLNode<T>,\n  prev?: Array<LLNode<T>>,\n): Array<LLNode<T>> => {\n  let arr: Array<LLNode<T>> = []\n  let i = 0\n  while (head) {\n    if (prev !== undefined && prev[i] !== head) prev = undefined\n    arr.push(head)\n    head = head[LL_NEXT]\n    i++\n  }\n  return arr.length === prev?.length ? prev : arr\n}\n\nexport function reatomLinkedList<Node extends Rec, Params extends any[] = [Node], Key extends keyof Node = never>(\n  initState: Array<Node>,\n  name?: string\n): LinkedListAtom<Params, Node, Key>;\n\nexport function reatomLinkedList<Params extends any[], Node extends Rec, Key extends keyof Node = never>(\n  initState: ((ctx: Ctx, ...params: Params) => Node),\n  name?: string\n): LinkedListAtom<Params, Node, Key>;\n\nexport function reatomLinkedList<Params extends any[], Node extends Rec, Key extends keyof Node = never>(\n  initState: {\n    create: (ctx: Ctx, ...params: Params) => Node\n    initState?: Array<Node>\n    key?: Key\n  },\n  name?: string\n): LinkedListAtom<Params, Node, Key>;\n\nexport function reatomLinkedList<Params extends any[], Node extends Rec, Key extends keyof Node = never>(\n  initState: {\n    create?: (ctx: Ctx, ...params: Params) => Node,\n    initState: Array<Node>,\n    key?: Key\n  },\n  name?: string\n): LinkedListAtom<Params, Node, Key>;\n\nexport function reatomLinkedList<Params extends any[], Node extends Rec, Key extends keyof Node = never>(\n  initSnapshot: {\n    create: (ctx: Ctx, ...params: Params) => Node,\n    initSnapshot?: Array<Params>,\n    key?: Key\n  },\n  name?: string\n): LinkedListAtom<Params, Node, Key>;\n\nexport function reatomLinkedList<Params extends any[], Node extends Rec, Key extends keyof Node = never>(\n  options:\n    | Array<Node>\n    | ((ctx: Ctx, ...params: Params) => Node)\n    | {\n      create?: (ctx: Ctx, ...params: Params) => Node\n      initState?: Array<Node>\n      key?: Key\n    }\n    | {\n      create: (ctx: Ctx, ...params: Params) => Node\n      initSnapshot?: Array<Params>\n      key?: Key\n    },\n  name = __count('reatomLinkedList'),\n): LinkedListAtom<Params, Node, Key> {\n  const {\n    create: userCreate = (ctx: Ctx, ...params: Params) => params[0],\n    key = undefined,\n    ...restOptions\n  } = typeof options === 'function' ? {\n    create: options\n  } : Array.isArray(options) ? {\n    create: (ctx: Ctx, ...params: Params) => params[0],\n    initState: options,\n  } : options;\n\n  const _name = name;\n\n  const isLL = (node: Node): node is LLNode<Node> =>\n    !!node && LL_NEXT in node && LL_PREV in node\n\n  const throwModel = (node: Node) =>\n    throwReatomError(isLL(node), 'The data is already in a linked list.')\n  const throwNotModel = (node: Node) =>\n    throwReatomError(!isLL(node), 'The passed data is not a linked list node.')\n\n  // for batching\n  let STATE: null | LinkedList<LLNode<Node>> = null\n\n  const linkedList = atom(STATE!, name)\n  linkedList.__reatom.initState = (ctx) => {\n    try {\n      if ('initState' in restOptions)\n        return createLinkedList(restOptions.initState ?? [])\n      else if ('initSnapshot' in restOptions)\n        return createLinkedList(ctx, restOptions.initSnapshot ?? [])\n      else return createLinkedList([])\n    } finally {\n      STATE = null\n    }\n  }\n\n  const createLinkedList = (\n    ctxOrInitState: Ctx | Node[],\n    initSnapshot?: Params[],\n  ): LinkedList<LLNode<Node>> => {\n    const initState = Array.isArray(ctxOrInitState)\n      ? ctxOrInitState\n      : initSnapshot!.map((params) => userCreate(ctxOrInitState, ...params))\n\n    const state = {\n      size: 0,\n      version: 1,\n      changes: [],\n      head: null,\n      tail: null,\n    }\n\n    for (const node of initState) {\n      throwModel(node)\n      addLL(state, node, state.tail)\n    }\n\n    return state\n  }\n\n  const batchFn = <T>(ctx: Ctx, cb: Fn<[Ctx], T>): T => {\n    if (STATE) return cb(ctx)\n\n    STATE = linkedList(ctx, ({ head, tail, size, version }) => ({\n      size,\n      version: version + 1,\n      changes: [],\n      head,\n      tail,\n    }))\n\n    try {\n      return cb(ctx)\n    } finally {\n      STATE = null\n    }\n  }\n\n  const batch = action(batchFn, `${name}._batch`)\n\n  const create = action((ctx, ...params: Params): LLNode<Node> => {\n    return batchFn(ctx, () => {\n      const node = userCreate(ctx, ...params) as LLNode<Node>\n\n      throwReatomError(\n        !isObject(node) && typeof node !== 'function',\n        `reatomLinkedList can operate only with objects or functions, received \"${node}\".`,\n      )\n      throwModel(node)\n\n      addLL(STATE!, node, STATE!.tail)\n\n      STATE!.changes.push({ kind: 'create', node })\n\n      return node\n    })\n  }, `${name}.create`)\n\n  const remove = action((ctx, node: LLNode<Node>): boolean => {\n    return batchFn(ctx, () => {\n      throwNotModel(node)\n\n      if (\n        node[LL_PREV] === null &&\n        node[LL_NEXT] === null &&\n        STATE!.tail !== node\n      )\n        return false\n\n      removeLL(STATE!, node)\n\n      STATE!.changes.push({ kind: 'remove', node })\n\n      return true\n    })\n  }, `${name}.remove`)\n\n  const swap = action((ctx, a: LLNode<Node>, b: LLNode<Node>): void => {\n    return batchFn(ctx, () => {\n      throwNotModel(a)\n      throwNotModel(b)\n\n      if (a === b) return\n\n      swapLL(STATE!, a, b)\n\n      STATE!.changes.push({ kind: 'swap', a, b })\n    })\n  }, `${name}.swap`)\n\n  const move = action(\n    (ctx, node: LLNode<Node>, after: null | LLNode<Node>): void => {\n      return batchFn(ctx, () => {\n        throwNotModel(node)\n\n        moveLL(STATE!, node, after)\n\n        STATE!.changes.push({ kind: 'move', node, after })\n      })\n    },\n    `${name}.move`,\n  )\n\n  const clear = action((ctx): void => {\n    return batchFn(ctx, () => {\n      clearLL(STATE!)\n\n      STATE!.changes.push({ kind: 'clear' })\n    })\n  }, `${name}.clear`)\n\n  const find = (\n    ctx: Ctx,\n    cb: (node: LLNode<Node>) => boolean,\n  ): null | LLNode<Node> => {\n    for (let { head } = ctx.get(linkedList); head; head = head[LL_NEXT]) {\n      if (cb(head)) return head\n    }\n    return null\n  }\n\n  const array: LinkedListAtom<Params, Node, Key>['array'] = atom(\n    (ctx, state: Array<LLNode<Node>> = []) =>\n      toArray(ctx.spy(linkedList).head, state),\n    `${name}.array`,\n  )\n\n  const map = key\n    ? (atom(\n        (ctx) =>\n          new Map(\n            // use array as it already memoized and simplifies the order tracking\n            ctx.spy(array).map((node) => {\n              const keyValue = node[key]\n              return [\n                isAtom(keyValue) ? ctx.spy(keyValue) : keyValue,\n                node,\n              ] as const\n            }),\n          ),\n      ) as LinkedListAtom<Params, Node, Key>['map'])\n    : (undefined as never)\n\n  const reatomMap = <T extends Rec>(\n    cb: (ctx: Ctx, node: LLNode<Node>) => T,\n    options:\n      | string\n      | {\n          name?: string\n          onCreate?: (ctx: Ctx, node: LLNode<T>) => void\n          onRemove?: (ctx: Ctx, node: LLNode<T>, origin: LLNode<Node>) => void\n          onSwap?: (ctx: Ctx, payload: { a: LLNode<T>; b: LLNode<T> }) => void\n          onMove?: (ctx: Ctx, node: LLNode<T>) => void\n          onClear?: (\n            ctx: Ctx,\n            lastState: LinkedListDerivedState<LLNode<Node>, LLNode<T>>,\n          ) => void\n        } = {},\n  ): LinkedListDerivedAtom<LLNode<Node>, LLNode<T>> => {\n    const { name = __count(`${_name}.reatomMap`), ...hooks } =\n      typeof options === 'string' ? { name: options } : options\n\n    type State = LinkedListDerivedState<LLNode<Node>, LLNode<T>>\n\n    const mapList = atom((ctx, mapList?: State): State => {\n      throwReatomError(\n        STATE,\n        `Can't compute the map of the linked list inside the batching.`,\n      )\n\n      const ll = ctx.spy(linkedList)\n\n      if (\n        !mapList ||\n        /* some update was missed */ ll.version - 1 > mapList.version\n      ) {\n        if (mapList) hooks.onClear?.(ctx, mapList)\n\n        mapList = {\n          size: ll.size,\n          version: ll.version,\n          changes: [],\n          head: null,\n          tail: null,\n          map: new WeakMap(),\n        }\n\n        for (let head = ll.head; head; head = head[LL_NEXT]) {\n          const node = cb(ctx, head) as LLNode<T>\n          addLL(mapList, node, mapList.tail)\n          mapList.map.set(head, node)\n          hooks.onCreate?.(ctx, node)\n        }\n        // cover extra size changes from `addLL`\n        mapList.size = ll.size\n      } else {\n        mapList = {\n          head: mapList.head,\n          tail: mapList.tail,\n          size: mapList.size,\n          version: ll.version,\n          changes: [],\n          map: mapList.map,\n        }\n\n        for (const change of ll.changes) {\n          switch (change.kind) {\n            case 'create': {\n              const node = cb(ctx, change.node) as LLNode<T>\n              addLL(mapList, node, mapList.tail)\n              mapList.map.set(change.node, node)\n              mapList.changes.push({ kind: 'create', node })\n              hooks.onCreate?.(ctx, node)\n              break\n            }\n            case 'remove': {\n              const node = mapList.map.get(change.node)!\n              removeLL(mapList, node)\n              mapList.map.delete(change.node)\n              mapList.changes.push({ kind: 'remove', node })\n              hooks.onRemove?.(ctx, node, change.node)\n              break\n            }\n            case 'swap': {\n              const a = mapList.map.get(change.a)!\n              const b = mapList.map.get(change.b)!\n              swapLL(mapList, a, b)\n              mapList.changes.push({ kind: 'swap', a, b })\n              hooks.onSwap?.(ctx, { a, b })\n              break\n            }\n            case 'move': {\n              const node = mapList.map.get(change.node)!\n              const after = change.after ? mapList.map.get(change.after)! : null\n              moveLL(mapList, node, after)\n              mapList.changes.push({ kind: 'move', node, after })\n              hooks.onMove?.(ctx, node)\n              break\n            }\n            case 'clear': {\n              hooks.onClear?.(ctx, mapList)\n              clearLL(mapList)\n              mapList.changes.push({ kind: 'clear' })\n              break\n            }\n            default: {\n              const kind: never = change\n              const error = new Error(`Unhandled linked list change \"${kind}\"`)\n              throw error\n            }\n          }\n        }\n      }\n\n      throwReatomError(\n        mapList.size !== ll.size,\n        \"Inconsistent linked list, is's a bug, please report an issue\",\n      )\n\n      return mapList\n    }, name)\n\n    const array: LinkedListDerivedAtom<LLNode<Node>, LLNode<T>>['array'] = atom(\n      (ctx, state: Array<LLNode<T>> = []) =>\n        toArray(ctx.spy(mapList).head, state),\n      `${name}.array`,\n    )\n\n    return Object.assign(mapList, { array, __reatomLinkedList: true as const })\n  }\n\n  // TODO there is a bug with `del` logic\n  // const reatomReduce = <T>(\n  //   {\n  //     init,\n  //     add,\n  //     del,\n  //   }: {\n  //     init: T\n  //     add: (ctx: CtxSpy, acc: T, node: LLNode<Node>) => T\n  //     del: (ctx: Ctx, acc: T, node: LLNode<Node>) => T\n  //   },\n  //   name = __count(`${_name}.reatomReduce`),\n  // ): Atom<T> => {\n  //   const acc = atom(init, `${name}._acc`)\n  //   const controllers = reatomMap(\n  //     (ctx, node) =>\n  //       atom(\n  //         (ctx) => {\n  //           acc(ctx, (state) =>\n  //             add(\n  //               ctx,\n  //               /* is the first calc */ ctx.cause.listeners.size\n  //                 ? del(ctx, state, node)\n  //                 : state,\n  //               node,\n  //             ),\n  //           )\n  //         },\n  //         __count(`${name}._controllers`),\n  //       ).pipe(\n  //         withAssign((target) => ({\n  //           unsubscribe: ctx.subscribe(target, noop),\n  //         })),\n  //       ),\n  //     {\n  //       name: `${name}._controllers`,\n  //       onRemove(ctx, node, origin) {\n  //         acc(ctx, (state) => del(ctx, state, origin))\n  //         node.unsubscribe()\n  //       },\n  //       onClear(ctx, mapList) {\n  //         for (let head = mapList.head; head; head = head[LL_NEXT]) {\n  //           head.unsubscribe()\n  //         }\n  //         acc(ctx, () => init)\n  //       },\n  //     },\n  //   )\n\n  //   onDisconnect(controllers, (ctx) => {\n  //     for (let head = ctx.get(controllers).head; head; head = head[LL_NEXT]) {\n  //       head.unsubscribe()\n  //     }\n  //   })\n\n  //   return atom((ctx) => {\n  //     ctx.spy(controllers)\n  //     return ctx.spy(acc)\n  //   }, name)\n  // }\n\n  return Object.assign(linkedList, {\n    batch,\n    create,\n    remove,\n    swap,\n    move,\n    clear,\n\n    find,\n\n    array,\n    map,\n    initiate: createLinkedList,\n\n    reatomMap,\n    // reatomFilter,\n    // reatomReduce,\n\n    __reatomLinkedList: true as const,\n  }).pipe(readonly)\n}\n\nexport const isLinkedListAtom = (thing: any): thing is LinkedListLikeAtom =>\n  thing?.__reatomLinkedList === true\n","import { Action, AtomMut, action, atom } from '@reatom/core'\nimport { withAssign } from './withAssign'\n\nexport interface NumberAtom extends AtomMut<number> {\n  increment: Action<[by?: number], number>\n  decrement: Action<[by?: number], number>\n  random: Action<[], number>\n  reset: Action<[], number>\n}\n\nexport const reatomNumber = (initState = 0, name?: string): NumberAtom =>\n  atom(initState, name).pipe(\n    withAssign((target, name) => ({\n      increment: action(\n        (ctx, by = 1) => target(ctx, (prev) => prev + by),\n        `${name}.increment`,\n      ),\n      decrement: action(\n        (ctx, by = 1) => target(ctx, (prev) => prev - by),\n        `${name}.decrement`,\n      ),\n      random: action((ctx) => target(ctx, Math.random()), `${name}.decrement`),\n      reset: action((ctx) => target(ctx, initState), `${name}.reset`),\n    })),\n  )\n","import { Action, action, atom, AtomMut, Rec } from '@reatom/core'\nimport { omit } from '@reatom/utils'\nimport { withAssign } from './withAssign'\n\nexport interface RecordAtom<T extends Rec> extends AtomMut<T> {\n  merge: Action<[slice: Partial<T>], T>\n  omit: Action<Array<keyof T>, T>\n  reset: Action<Array<keyof T>, T>\n}\n\nexport const reatomRecord = <T extends Rec>(\n  initState: T,\n  name?: string,\n): RecordAtom<T> =>\n  atom(initState, name).pipe(\n    withAssign((target) => ({\n      merge: action(\n        (ctx, slice: Partial<T>) =>\n          target(ctx, (prev) => {\n            for (const key in prev) {\n              if (!Object.is(prev[key], slice[key])) {\n                return { ...prev, ...slice }\n              }\n            }\n            return prev\n          }),\n        `${name}.merge`,\n      ),\n\n      omit: action(\n        (ctx, ...keys: Array<keyof T>) =>\n          target(ctx, (prev) => {\n            if (keys.some((key) => key in prev)) return omit(prev, keys) as any\n            return prev\n          }),\n        `${name}.omit`,\n      ),\n\n      reset: action(\n        (ctx, ...keys: (keyof T)[]) =>\n          target(ctx, (prev) => {\n            if (keys.length === 0) return initState\n            const next = {} as T\n            let changed = false\n            for (const key in prev) {\n              if (keys.includes(key)) {\n                if (key in initState) {\n                  next[key] = initState[key]\n                  changed ||= !Object.is(prev[key], initState[key])\n                } else {\n                  changed ||= key in prev\n                }\n              } else {\n                next[key] = prev[key]\n              }\n            }\n            return changed ? next : prev\n          }),\n        `${name}.reset`,\n      ),\n    })),\n  )\n","import { Action, action, atom, Atom, AtomMut, Ctx } from '@reatom/core'\nimport { withAssign } from './withAssign'\n\nexport interface SetLikeAtom<T = any> extends AtomMut<Set<T>> {\n  __reatomSet: true\n}\n\nexport interface SetAtom<T> extends SetLikeAtom<T> {\n  add: Action<[el: T], Set<T>>\n  delete: Action<[el: T], Set<T>>\n  toggle: Action<[el: T], Set<T>>\n  clear: Action<[], Set<T>>\n  reset: Action<[], Set<T>>\n  intersection: Action<[set: Set<T>], Set<T>>\n  union: Action<[set: Set<T>], Set<T>>\n  difference: Action<[set: Set<T>], Set<T>>\n  symmetricDifference: Action<[set: Set<T>], Set<T>>\n  has: (ctx: Ctx, el: T) => boolean\n  isSubsetOf: (ctx: Ctx, set: Set<T>) => boolean\n  isSupersetOf: (ctx: Ctx, set: Set<T>) => boolean\n  isDisjointFrom: (ctx: Ctx, set: Set<T>) => boolean\n  size: (ctx: Ctx) => number\n  /** @deprecated */\n  set: Action<[el: T], Set<T>>\n  sizeAtom: Atom<number>\n}\n\n// @ts-ignore TODO is it already ok to remove this?\ninterface ProposalSet<T> extends Set<T> {\n  difference(other: Set<T>): Set<T>\n  intersection(other: Set<T>): Set<T>\n  isDisjointFrom(other: Set<T>): boolean\n  isSubsetOf(other: Set<T>): boolean\n  isSupersetOf(other: Set<T>): boolean\n  symmetricDifference(other: Set<T>): Set<T>\n  union(other: Set<T>): Set<T>\n}\n\ntype FirstSetConstructorParam<T> = ConstructorParameters<typeof Set<T>>[0]\n\nexport const reatomSet = <T>(\n  initState: Set<T> | FirstSetConstructorParam<T> = new Set<T>(),\n  name?: string,\n): SetAtom<T> => {\n  const atomInitState = initState instanceof Set ? initState : new Set(initState);\n  \n  return atom(atomInitState, name).pipe(\n    withAssign((target, name) => ({\n      __reatomSet: true as const,\n      \n      add: action(\n        (ctx, el) =>\n          target(ctx, (prev) => (prev.has(el) ? prev : new Set(prev).add(el))),\n        `${name}.add`,\n      ),\n      /** @deprecated */\n      set: action(\n        (ctx, el) =>\n          target(ctx, (prev) => (prev.has(el) ? prev : new Set(prev).add(el))),\n        `${name}.set`,\n      ),\n      delete: action((ctx, el) => {\n        return target(ctx, (prev) => {\n          if (!prev.has(el)) return prev\n          const next = new Set(prev)\n          next.delete(el)\n          return next\n        })\n      }, `${name}.delete`),\n      clear: action((ctx) => {\n        return target(ctx, (prev) => {\n          if (prev.size === 0) return prev\n          return new Set<T>()\n        })\n      }, `${name}.clear`),\n      reset: action((ctx) => target(ctx, atomInitState), `${name}.reset`),\n      intersection: action(\n        (ctx, set) =>\n          target(ctx, (prev) => (prev as ProposalSet<T>).intersection(set)),\n        `${name}.intersection`,\n      ),\n      union: action(\n        (ctx, set) =>\n          target(ctx, (prev) => (prev as ProposalSet<T>).union(set)),\n        `${name}.union`,\n      ),\n      difference: action(\n        (ctx, set) =>\n          target(ctx, (prev) => (prev as ProposalSet<T>).difference(set)),\n        `${name}.difference`,\n      ),\n      symmetricDifference: action(\n        (ctx, set) =>\n          target(ctx, (prev) =>\n            (prev as ProposalSet<T>).symmetricDifference(set),\n          ),\n        `${name}.symmetricDifference`,\n      ),\n      toggle: action((ctx, el) => {\n        return target(ctx, (prev) => {\n          if (!prev.has(el)) return new Set(prev).add(el)\n          const next = new Set(prev)\n          next.delete(el)\n          return next\n        })\n      }, `${name}.toggle`),\n      has: (ctx: Ctx, el: T) => ctx.get(target).has(el),\n      isSubsetOf: (ctx: Ctx, set: Set<T>) =>\n        (ctx.get(target) as ProposalSet<T>).isSubsetOf(set),\n      isSupersetOf: (ctx: Ctx, set: Set<T>) =>\n        (ctx.get(target) as ProposalSet<T>).isSupersetOf(set),\n      isDisjointFrom: (ctx: Ctx, set: Set<T>) =>\n        (ctx.get(target) as ProposalSet<T>).isDisjointFrom(set),\n      size: (ctx: Ctx) => ctx.get(target).size,\n      sizeAtom: atom((ctx) => ctx.spy(target).size, `${name}.size`),\n    })),\n  )\n}\n\nexport const isSetAtom = (thing: any): thing is SetLikeAtom => thing?.__reatomSet === true\n","import { Action, action, atom, AtomMut } from '@reatom/core'\nimport { withAssign } from './withAssign'\n\nexport type StringAtom<T extends string = string> = AtomMut<T> & {\n  reset: Action<[], T>\n}\n\nexport const reatomString: {\n  (init?: string, name?: string): StringAtom\n  <T extends string>(init: T, name?: string): StringAtom<T>\n} = (init = '', name?: string) =>\n  atom(init, name).pipe(\n    withAssign((target, name) => ({\n      reset: action((ctx) => target(ctx, init), `${name}.reset`),\n    })),\n  )\n","import { Atom, AtomState, CtxSpy } from '@reatom/core'\n\nexport const withComputed =\n  <T extends Atom>(\n    computed: (ctx: CtxSpy, state: AtomState<T>) => AtomState<T>,\n  ) =>\n  (anAtom: T): T => {\n    const prevComputed = anAtom.__reatom.computer\n    anAtom.__reatom.computer = (ctx, state) => {\n      if (prevComputed) {\n        state = prevComputed(ctx, state)\n      }\n      return computed(ctx, state as AtomState<T>)\n    }\n    return anAtom\n  }\n","import { action, Action, AtomMut, AtomState, Fn, Rec } from '@reatom/core'\n\ninterface Reducers<A extends AtomMut>\n  extends Rec<(state: AtomState<A>, ...args: Array<any>) => AtomState<A>> {}\n\nexport type WithReducers<A extends AtomMut, R extends Reducers<A>> = A & {\n  [K in keyof R]: R[K] extends Fn<[any, ...infer Args]>\n    ? Action<Args, AtomState<A>>\n    : never\n}\n\n/** @deprecated use withAssign instead */\nexport const withReducers =\n  <A extends AtomMut, R extends Reducers<A>>(reducers: R) =>\n  (anAtom: A) =>\n    Object.keys(reducers).reduce((anAtom, k) => {\n      ;(anAtom as any)[k] = action(\n        (ctx, ...args) => anAtom(ctx, reducers[k]!(ctx.get(anAtom), ...args)),\n        `${anAtom.__reatom.name}._${k}`,\n      )\n      return anAtom\n    }, anAtom) as WithReducers<A, R>\n"],"mappings":"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"}