{"version":3,"file":"effector-react.mjs","sources":["effector-react/withDisplayName.ts","effector-react/apiBase.ts","effector-react/scope.ts","effector-react/nossr.ts","effector-react/createComponent.ts","effector-react/createStoreConsumer.ts","effector-react/../effector/config.ts","effector-react/../effector/is.ts","effector-react/../effector/throw.ts","effector-react/createGate.ts","effector-react/throw.ts","effector-react/useIsomorphicLayoutEffect.ts","effector-react/useDeprecate.ts","effector-react/deprecate.ts","effector-react/connect.ts","effector-react/../effector/collection.ts"],"sourcesContent":["export function withDisplayName(name: string, Component: any) {\n  Component.displayName = name\n  return Component\n}\n","import {Store, is, scopeBind, Scope, Unit, Event, createWatch} from 'effector'\nimport React from 'react'\nimport {useSyncExternalStore} from 'use-sync-external-store/shim'\nimport {useSyncExternalStoreWithSelector} from 'use-sync-external-store/shim/with-selector'\nimport {throwError} from './throw'\nimport {withDisplayName} from './withDisplayName'\nimport {useIsomorphicLayoutEffect} from './useIsomorphicLayoutEffect'\nimport {Gate} from './index.h'\nimport {useDeprecate} from './useDeprecate'\n\nconst stateReader = <T>(store: Store<T>, scope?: Scope) =>\n  scope ? scope.getState(store) : store.getState()\nconst basicUpdateFilter = <T>(upd: T, oldValue: T) => upd !== oldValue\nconst keysEqual = (a?: readonly any[], b?: readonly any[]) => {\n  if (!a || !b || a.length !== b.length) return false\n\n  let isEqual = true\n\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) {\n      isEqual = false\n      break\n    }\n  }\n\n  return isEqual\n}\n\nexport function useStoreBase<State>(store: Store<State>, scope?: Scope) {\n  useDeprecate(true, 'useStore', 'useUnit')\n  if (!is.store(store)) throwError('expect useStore argument to be a store')\n\n  const subscribe = React.useCallback(\n    (fn: () => void) => createWatch({unit: store, fn, scope}),\n    [store, scope],\n  )\n  const read = React.useCallback(\n    () => stateReader(store, scope),\n    [store, scope],\n  )\n  const currentValue = useSyncExternalStore(subscribe, read, read)\n\n  return currentValue\n}\n\nexport function useUnitBase<Shape extends {[key: string]: Unit<any>}>(\n  shape: Shape | {'@@unitShape': () => Shape},\n  scope?: Scope,\n) {\n  const isSingleUnit = is.unit(shape)\n  let normShape: {[key: string]: Unit<any>} = {}\n  if (isSingleUnit) {\n    normShape = {unit: shape}\n  } else if ('@@unitShape' in shape) {\n    if (typeof shape['@@unitShape'] === 'function') {\n      normShape = shape['@@unitShape']()\n    } else {\n      throwError('expect @@unitShape to be a function')\n    }\n  } else {\n    normShape = shape\n  }\n  const isList = Array.isArray(normShape)\n  const flagsRef = React.useRef({\n    stale: true,\n    justSubscribed: false,\n    scope,\n  })\n  const [eventsShape, storeKeys, storeValues, eventKeys, eventValues] =\n    React.useMemo(() => {\n      flagsRef.current.stale = true\n      const shape = Array.isArray(normShape) ? [] : ({} as any)\n      const storeKeys: string[] = []\n      const storeValues: Array<Store<any>> = []\n      const eventKeys: string[] = []\n      const eventValues: Array<Unit<any>> = []\n      for (const key in normShape) {\n        if (!Object.prototype.hasOwnProperty.call(normShape, key)) continue\n        const unit = normShape[key]\n        if (!is.unit(unit)) {\n          const keyMessage = isSingleUnit ? 'argument' : `value in key \"${key}\"`\n          throwError(`expect useUnit ${keyMessage} to be a unit`)\n        }\n        if (is.event(unit) || is.effect(unit)) {\n          shape[key] = scope ? scopeBind(unit as Event<any>, {scope}) : unit\n          eventKeys.push(key)\n          eventValues.push(unit)\n        } else {\n          shape[key] = null\n          storeKeys.push(key)\n          storeValues.push(unit as Store<any>)\n        }\n      }\n      return [shape, storeKeys, storeValues, eventKeys, eventValues]\n    }, [\n      flagsRef,\n      scope,\n      ...Object.keys(normShape),\n      ...Object.values(normShape),\n    ])\n  const stateRef = React.useRef({\n    value: eventsShape,\n    storeKeys,\n    eventKeys,\n    eventValues,\n  })\n  const subscribe = React.useCallback(\n    (cb: () => void) => {\n      const flags = flagsRef.current\n      flags.justSubscribed = true\n      const cbCaller = () => {\n        if (!flags.stale) {\n          flags.stale = true\n          cb()\n        }\n      }\n      return createWatch({unit: storeValues, fn: cbCaller, scope, batch: true})\n    },\n    [storeValues, scope, stateRef, flagsRef],\n  )\n  const read = React.useCallback(() => {\n    const state = stateRef.current\n    const flags = flagsRef.current\n    let resultValue\n    let changed = false\n    const oldVal = state.value\n    const oldStoreKeys = state.storeKeys\n    const oldEventKeys = state.eventKeys\n    const oldEventValues = state.eventValues\n    const scopeChanged = scope !== flags.scope\n    if (flags.stale || flags.justSubscribed || scopeChanged) {\n      changed = !flags.justSubscribed || scopeChanged\n      resultValue = isList ? [...eventsShape] : {...eventsShape}\n      if (\n        oldStoreKeys.length !== storeKeys.length ||\n        oldEventKeys.length !== eventKeys.length\n      ) {\n        changed = true\n      }\n      for (let i = 0; i < storeKeys.length; i++) {\n        const updatedValue = stateReader(storeValues[i], scope)\n        const key = storeKeys[i]\n        if (!changed) {\n          if (!oldStoreKeys.includes(key)) {\n            changed = true\n          } else {\n            changed = oldVal[key] !== updatedValue\n          }\n        }\n        resultValue[key] = updatedValue\n      }\n      for (let i = 0; i < eventKeys.length; i++) {\n        const updatedValue = eventValues[i]\n        const key = eventKeys[i]\n        if (!changed) {\n          if (!oldEventKeys.includes(key)) {\n            changed = true\n          } else {\n            changed = oldEventValues[oldEventKeys.indexOf(key)] !== updatedValue\n          }\n        }\n      }\n    }\n    if (changed) {\n      state.value = resultValue\n    }\n    state.storeKeys = storeKeys\n    state.eventKeys = eventKeys\n    state.eventValues = eventValues\n    flags.stale = false\n    flags.justSubscribed = !changed\n    flags.scope = scope\n    return isSingleUnit ? state.value.unit : state.value\n  }, [subscribe, storeValues, eventValues, scope, stateRef, flagsRef])\n  return useSyncExternalStore(subscribe, read, read)\n}\n\nexport function useStoreMapBase<State, Result, Keys extends ReadonlyArray<any>>(\n  [configOrStore, separateFn]: [\n    configOrStore:\n      | {\n          store: Store<State>\n          keys: Keys\n          fn(state: State, keys: Keys): Result\n          updateFilter?: (update: Result, current: Result) => boolean\n          defaultValue?: Result\n        }\n      | Store<State>,\n    separateFn?: (state: State, keys: Keys) => Result,\n  ],\n  scope?: Scope,\n): Result {\n  let fn: (state: State, keys: Keys) => Result\n  let updateFilter: (update: Result, current: Result) => boolean =\n    basicUpdateFilter\n  let defaultValue: Result | undefined\n  let store: Store<State>\n  let keys: Keys\n  if (separateFn) {\n    fn = separateFn\n    store = configOrStore as Store<State>\n    keys = [] as unknown as Keys\n  } else {\n    ;({\n      fn,\n      store,\n      keys,\n      defaultValue,\n      updateFilter = basicUpdateFilter,\n    } = configOrStore as any)\n  }\n  if (!is.store(store)) throwError('useStoreMap expects a store')\n  if (!Array.isArray(keys)) throwError('useStoreMap expects an array as keys')\n  if (typeof fn !== 'function') throwError('useStoreMap expects a function')\n\n  const subscribe = React.useCallback(\n    (fn: () => void) => createWatch({unit: store, fn, scope}),\n    [store, scope],\n  )\n  const read = React.useCallback(\n    () => stateReader(store, scope),\n    [store, scope],\n  )\n\n  const stateRef = React.useRef<State>()\n  const valueRef = React.useRef<Result>()\n  const keysRef = React.useRef(keys)\n\n  const value = useSyncExternalStoreWithSelector(\n    subscribe,\n    read,\n    read,\n    state => {\n      if (stateRef.current !== state || !keysEqual(keysRef.current, keys)) {\n        let result = fn(state, keys)\n        if (result === undefined && defaultValue !== undefined) {\n          result = defaultValue\n        }\n        stateRef.current = state\n        keysRef.current = keys\n\n        /**\n         * skip update, if undefined\n         * just like original store or previous implementation\n         */\n        if (result !== undefined) {\n          valueRef.current = result\n        }\n      }\n\n      return valueRef.current as Result\n    },\n    (current, update) => !updateFilter(update, current),\n  )\n\n  return value\n}\nexport function useListBase<T>(\n  list: Store<T[]>,\n  renderItem:\n    | {\n        keys?: any[]\n        fn(item: T, index: number): React.ReactNode\n        getKey?: (item: T) => string\n        placeholder?: React.ReactNode\n      }\n    | ((item: T, index: number) => React.ReactNode),\n  scope?: Scope,\n): React.ReactNode {\n  let keys = [] as any[]\n  let fn\n  let getKey: ((item: T) => string) | void\n  let placeholder: React.ReactNode | void\n  if (typeof renderItem === 'object' && renderItem !== null) {\n    if (renderItem.keys) keys = renderItem.keys\n    ;({fn, getKey, placeholder} = renderItem)\n  } else {\n    fn = renderItem\n  }\n  if (!is.store(list)) throwError('expect useList first argument to be a store')\n  if (typeof fn !== 'function')\n    throwError(\"expect useList's renderItem to be a function\")\n  if (!Array.isArray(keys)) throwError(\"expect useList's keys to be an array\")\n  const Item = React.useMemo(() => {\n    const Item = withDisplayName(\n      `${list.shortName || 'Unknown'}.Item`,\n      (\n        props:\n          | {index: number; keys: any[]; keyVal: never; value: never}\n          | {index: never; keys: any[]; keyVal: string; value: T},\n      ) => {\n        const {index, keys, keyVal, value} = props\n        const isKeyed = !!fnRef.current[1]\n        if (isKeyed) {\n          return fnRef.current[0](value, keyVal as any)\n        }\n        const item = useStoreMapBase(\n          [\n            {\n              store: list,\n              keys: [index, ...keys],\n              fn: (list, keys) => list[keys[0]],\n            },\n          ],\n          scope,\n        )\n        return fnRef.current[0](item, index)\n      },\n    )\n    return React.memo(Item)\n  }, [list, scope, !!getKey!])\n  const fnRef = React.useRef([fn, getKey!] as const)\n  fnRef.current = [fn, getKey!]\n  const keysSelfMemo = React.useMemo(() => keys, keys)\n  if (getKey!) {\n    const listItems = useUnitBase(list, scope)\n    if (listItems.length === 0 && placeholder) return placeholder\n    return listItems.map(value => {\n      const key = fnRef.current[1](value)\n      return React.createElement(Item, {\n        keyVal: key,\n        key,\n        keys: keysSelfMemo,\n        value,\n      })\n    })\n  } else {\n    const length = useStoreMapBase(\n      [\n        {\n          store: list,\n          keys: [list],\n          fn: list => list.length,\n        },\n      ],\n      scope,\n    )\n    if (length === 0 && placeholder) return placeholder\n    return Array.from({length}, (_, i) =>\n      React.createElement(Item, {\n        index: i,\n        key: i,\n        keys: keysSelfMemo,\n      }),\n    )\n  }\n}\n\nexport function useEventBase(eventObject: any, scope?: Scope) {\n  useDeprecate(true, 'useEvent', 'useUnit')\n  if (!scope) {\n    return eventObject\n  }\n  const isShape = !is.unit(eventObject) && typeof eventObject === 'object'\n  const events = isShape ? eventObject : {event: eventObject}\n\n  return React.useMemo(() => {\n    if (is.unit(eventObject)) {\n      //@ts-expect-error\n      return scopeBind(eventObject, {scope})\n    }\n    const shape = Array.isArray(eventObject) ? [] : ({} as any)\n    for (const key in eventObject) {\n      shape[key] = scopeBind(eventObject[key], {scope})\n    }\n    return shape\n  }, [scope, ...Object.keys(events), ...Object.values(events)])\n}\n\nexport function useGateBase<Props>(\n  GateComponent: Gate<Props>,\n  props: Props = {} as any,\n  scope?: Scope,\n) {\n  const {open, close, set} = useUnitBase(\n    {\n      open: GateComponent.open,\n      close: GateComponent.close,\n      set: GateComponent.set,\n    },\n    scope,\n  )\n  const ForkedGate = React.useMemo(\n    () =>\n      ({\n        open,\n        close,\n        set,\n      } as Gate<Props>),\n    [GateComponent, open],\n  )\n\n  const propsRef = React.useRef<{value: any; count: number}>({\n    value: null,\n    count: 0,\n  })\n  useIsomorphicLayoutEffect(() => {\n    ForkedGate.open(propsRef.current.value)\n    return () => ForkedGate.close(propsRef.current.value) as any\n  }, [ForkedGate])\n  if (!shallowCompare(propsRef.current.value, props)) {\n    propsRef.current.value = props\n    propsRef.current.count += 1\n  }\n  useIsomorphicLayoutEffect(() => {\n    ForkedGate.set(propsRef.current.value)\n  }, [propsRef.current.count])\n}\n\nfunction shallowCompare(a: any, b: any) {\n  if (a === b) return true\n  if (\n    typeof a === 'object' &&\n    a !== null &&\n    typeof b === 'object' &&\n    b !== null\n  ) {\n    const aKeys = Object.keys(a)\n    const bKeys = Object.keys(b)\n    if (aKeys.length !== bKeys.length) return false\n    for (let i = 0; i < aKeys.length; i++) {\n      const key = aKeys[i]\n      if (a[key] !== b[key]) return false\n    }\n    return true\n  }\n  return false\n}\n","import React from 'react'\nimport {Scope} from 'effector'\nimport {throwError} from './throw'\n\nconst ScopeContext = React.createContext(null as Scope | null)\nexport const {Provider} = ScopeContext\nexport function getScope(forceScope?: boolean) {\n  const scope = React.useContext(ScopeContext)\n  if (forceScope && !scope)\n    throwError('No scope found, consider adding <Provider> to app root')\n  return scope as Scope\n}\n","import {Event, Store, Scope} from 'effector'\nimport {\n  useStoreBase,\n  useStoreMapBase,\n  useListBase,\n  useUnitBase,\n  useEventBase,\n  useGateBase,\n} from './apiBase'\nimport {getScope} from './scope'\nimport type {Gate} from './index.h'\n\n/**\nbind event to scope\n\nworks like React.useCallback, but for scopes\n*/\nexport function useEvent<T>(\n  event: Event<T>,\n  opts?: {forceScope?: boolean},\n): (payload: T) => T {\n  const scope = getScope(opts?.forceScope)\n\n  return useEventBase(event, scope)\n}\n\nexport function useStore<State>(\n  store: Store<State>,\n  opts?: {forceScope?: boolean},\n): State {\n  return useStoreBase(store, getScope(opts?.forceScope))\n}\n\nexport function useUnit(shape, opts?: {forceScope?: boolean}) {\n  return useUnitBase(shape, getScope(opts?.forceScope))\n}\n\nexport function useStoreMap<State, Result, Keys extends ReadonlyArray<any>>(\n  configOrStore:\n    | {\n        store: Store<State>\n        keys: Keys\n        fn(state: State, keys: Keys): Result\n        updateFilter?: (update: Result, current: Result) => boolean\n        defaultValue?: Result\n        forceScope?: boolean\n      }\n    | Store<State>,\n  separateFn?: (state: State, keys: Keys) => Result,\n): Result {\n  return useStoreMapBase(\n    [configOrStore, separateFn],\n    getScope(configOrStore?.forceScope),\n  )\n}\n\nexport function useList<T>(\n  list: Store<T[]>,\n  renderItem:\n    | {\n        keys?: any[]\n        fn(item: T, index: number): React.ReactNode\n        getKey?: (item: T) => string\n        placeholder?: React.ReactNode\n      }\n    | ((item: T, index: number) => React.ReactNode),\n  opts?: {forceScope?: boolean},\n): React.ReactNode {\n  return useListBase(list, renderItem, getScope(opts?.forceScope))\n}\n\nexport function useGate<Props>(\n  GateComponent: Gate<Props>,\n  props: Props = {} as any,\n  opts?: {forceScope?: boolean},\n) {\n  return useGateBase(GateComponent, props, getScope(opts?.forceScope))\n}\n\nexport function useProvidedScope(): Scope | null {\n  const scope = getScope() || null\n  return scope\n}\n","import React from 'react'\nimport {Store, is, combine, createEvent} from 'effector'\nimport {useStore} from './nossr'\nimport {useIsomorphicLayoutEffect} from './useIsomorphicLayoutEffect'\nimport {StoreView} from './index.h'\nimport {withDisplayName} from './withDisplayName'\nimport {throwError} from './throw'\nimport {deprecate} from './deprecate'\n\nexport function createComponent<Props, State>(\n  shape: Store<State> | {[key: string]: Store<any> | any},\n  renderProp: (props: Props, state: State) => React.ReactNode,\n): StoreView<State, Props> {\n  deprecate('createComponent', '@effector/reflect')\n  let store: Store<any>\n  if (is.store(shape)) {\n    store = shape\n  } else {\n    if (typeof shape === 'object' && shape !== null) {\n      store = combine(shape)\n    } else throwError('shape should be a store or object with stores')\n  }\n  let storeName = 'Unknown'\n  //@ts-ignore\n  if (store && store.shortName) {\n    storeName = store.shortName\n  }\n  const mounted = createEvent<any>()\n  const unmounted = createEvent<any>()\n\n  function RenderComponent(props: Props) {\n    const propsRef = React.useRef(props)\n    const state = useStore(store)\n    useIsomorphicLayoutEffect(() => {\n      mounted({props: propsRef.current, state: store.getState()})\n      return () => {\n        unmounted({props: propsRef.current, state: store.getState()})\n      }\n    }, [])\n    const result = renderProp(props, state)\n    propsRef.current = props\n    return result\n  }\n  RenderComponent.mounted = mounted\n  RenderComponent.unmounted = unmounted\n  return withDisplayName(`${storeName}.View`, RenderComponent)\n}\n","import {Store} from 'effector'\n\nimport {StoreConsumer} from './index.h'\nimport {createComponent} from './createComponent'\nimport {deprecate} from './deprecate'\n\nexport function createStoreConsumer<State>(\n  store: Store<State>,\n): StoreConsumer<State> {\n  deprecate('createStoreConsumer', 'useUnit')\n  return createComponent(store, ({children}, state) => children(state))\n}\n","import {forIn} from './collection'\nimport {assertObject, isObject, isVoid} from './is'\n\nexport function processArgsToConfig(\n  arg: any,\n  singleArgument: true,\n): [any, any | void]\nexport function processArgsToConfig(args: any[]): [any[], any | void]\nexport function processArgsToConfig(\n  args: any[],\n  singleArgument?: boolean,\n): [any[], any | void] {\n  const rawConfig = singleArgument ? args : args[0]\n  assertObject(rawConfig)\n  let metadata = rawConfig.or\n  const childConfig = rawConfig.and\n  if (childConfig) {\n    const unwrappedNestedValue = singleArgument ? childConfig : childConfig[0]\n    /**\n     * if there is no \"and\" field then we reached the leaf of the tree\n     * and this is an original user-defined argument\n     *\n     * note that in this case we're returning all arguments, not the only one been unwrapped\n     **/\n    if (!isObject(unwrappedNestedValue) || !('and' in unwrappedNestedValue)) {\n      args = childConfig\n    } else {\n      //@ts-expect-error\n      const nested = processArgsToConfig(childConfig, singleArgument)\n\n      args = nested[0]\n      metadata = {...metadata, ...nested[1]}\n    }\n  }\n  return [args, metadata]\n}\n\n/**\nprocessed fields:\n\n'name',\n'sid',\n'loc',\n'handler',\n'updateFilter',\n'parent',\n'serialize',\n'named',\n'derived',\n*/\nexport const flattenConfig = (part: any, config: Record<string, any> = {}) => {\n  if (isObject(part)) {\n    flattenConfig(part.or, config)\n    forIn(part, (value, field) => {\n      if (!isVoid(value) && field !== 'or' && field !== 'and') {\n        config[field] = value\n      }\n    })\n    flattenConfig(part.and, config)\n  }\n  return config\n}\n","export * as is from './validate'\nimport {forEach} from './collection'\nimport {assert} from './throw'\nimport {arrifyNodes} from './createNode'\nimport type {NodeUnit} from './index.h'\nimport type {DataCarrier} from './unit.h'\nimport {getMeta} from './getter'\n\nexport const isObject = (value: unknown): value is Record<any, any> =>\n  typeof value === 'object' && value !== null\nexport const isFunction = (value: unknown): value is Function =>\n  typeof value === 'function'\n\nexport const isVoid = (value: unknown): value is void => value === undefined\n\nexport const assertObject = (value: unknown) =>\n  assert(\n    isObject(value) || isFunction(value),\n    'expect first argument be an object',\n  ) // or function\n\nconst assertNodeSetItem = (\n  value: unknown,\n  method: string,\n  valueName: string,\n  reason: string,\n): asserts value is DataCarrier =>\n  assert(\n    !(\n      (!isObject(value) && !isFunction(value)) ||\n      (!('family' in value) && !('graphite' in value))\n    ),\n    `${method}: expect ${valueName} to be a unit (store, event or effect)${reason}`,\n  )\n\nexport const assertNodeSet = (\n  value: unknown,\n  method: string,\n  valueName: string,\n) => {\n  if (Array.isArray(value)) {\n    forEach(value, (item, i) =>\n      assertNodeSetItem(item, method, `${i} item of ${valueName}`, ''),\n    )\n  } else {\n    //@ts-expect-error some ts assertion edge case\n    assertNodeSetItem(value, method, valueName, ' or array of units')\n  }\n}\n\nexport const assertTarget = (\n  method: string,\n  target: NodeUnit | NodeUnit[],\n  targetField: string = 'target',\n) =>\n  forEach(arrifyNodes(target), item =>\n    assert(\n      !getMeta(item, 'derived'),\n      `${method}: derived unit in \"${targetField}\" is not supported, use createStore/createEvent instead\"`,\n    ),\n  )\n","export function assert(\n  condition: unknown,\n  message: string,\n  errorTitle?: string,\n): asserts condition {\n  if (!condition)\n    throw Error(`${errorTitle ? errorTitle + ': ' : ''}${message}`)\n}\n\nexport const deprecate = (\n  condition: unknown,\n  subject: string,\n  suggestion?: string,\n  errorTitle?: string,\n) =>\n  !condition &&\n  console.error(\n    `${errorTitle ? errorTitle + ': ' : ''}${subject} is deprecated${\n      suggestion ? `, use ${suggestion} instead` : ''\n    }`,\n  )\n","import {createStore, launch, Domain, createEvent} from 'effector'\nimport {Gate} from './index.h'\nimport {withDisplayName} from './withDisplayName'\nimport {useGateBase} from './apiBase'\nimport {getScope} from './scope'\nimport {flattenConfig, processArgsToConfig} from '../effector/config'\nimport {isObject} from '../effector/is'\n\nexport function createGateImplementation<State>({\n  domain,\n  defaultState,\n  hook: useGateHook,\n  mainConfig,\n  maybeConfig,\n}: {\n  domain?: Domain\n  defaultState: State | {}\n  hook: typeof useGateBase\n  mainConfig?: Record<string, any>\n  maybeConfig?: Record<string, any> & {sid?: string}\n}): Gate<State> {\n  const config = flattenConfig({\n    or: maybeConfig,\n    and: mainConfig,\n  }) as {sid: string | undefined; name: string | undefined}\n  const name = config.name || 'gate'\n  const fullName = `${domain ? `${domain.compositeName.fullName}/` : ''}${name}`\n  const set = createEvent<State>({\n    name: `${fullName}.set`,\n    sid: config.sid ? `${config.sid}|set` : undefined,\n  })\n  const open = createEvent<State>({\n    name: `${fullName}.open`,\n    sid: config.sid ? `${config.sid}|open` : undefined,\n  })\n  const close = createEvent<State>({\n    name: `${fullName}.close`,\n    sid: config.sid ? `${config.sid}|close` : undefined,\n  })\n  const status = createStore(Boolean(false), {\n    name: `${fullName}.status`,\n    serialize: 'ignore',\n    // doesn't need to have sid, because it is internal store, should not be serialized\n  })\n    .on(open, () => Boolean(true))\n    .on(close, () => Boolean(false))\n  const state = createStore(defaultState as State, {\n    name: `${fullName}.state`,\n    sid: config.sid,\n  })\n    .on(set, (_, state) => state)\n    .on(open, (_, state) => state)\n    .reset(close)\n  if (domain) {\n    const {hooks} = domain as any\n    launch({\n      target: [\n        hooks.store,\n        hooks.store,\n        hooks.event,\n        hooks.event,\n        hooks.event,\n      ] as any,\n      params: [status, state, open, close, set],\n    })\n  }\n  function GateComponent(props: State) {\n    useGateHook(GateComponent as any, props, getScope())\n    return null\n  }\n  GateComponent.open = open\n  GateComponent.close = close\n  GateComponent.status = status\n  GateComponent.state = state\n  GateComponent.set = set\n  return withDisplayName(`Gate:${fullName}`, GateComponent)\n}\n\nconst isPluginConfig = (config: Record<string, any> | string) =>\n  isObject(config) && 'sid' in config\n\nconst isGateConfig = (config: Record<string, any> | string) =>\n  isObject(config) &&\n  ('domain' in config || 'defaultState' in config || 'name' in config)\n\nconst isStructuredConfig = (arg: unknown) =>\n  isObject(arg) && (arg.and || arg.or)\n\nexport function processCreateGateConfig<State>(\n  hook: typeof useGateBase,\n  args: unknown[],\n): {\n  domain?: Domain\n  defaultState: State | {}\n  hook: typeof useGateBase\n  mainConfig?: Record<string, any>\n  maybeConfig?: Record<string, any> & {sid?: string}\n} {\n  const universalConfig =\n    args && isStructuredConfig(args[0]) ? args : [{and: args}]\n  const [[nameOrConfig, defaultStateOrConfig], metadata] =\n    processArgsToConfig(universalConfig)\n\n  let domain\n  let defaultState = {}\n  let mainConfig = {}\n  let maybeConfig = metadata\n\n  if (typeof nameOrConfig === 'string') {\n    mainConfig = {name: nameOrConfig}\n    if (isPluginConfig(defaultStateOrConfig)) {\n      // maybeConfig = defaultStateOrConfig\n    } else {\n      defaultState = defaultStateOrConfig || {}\n    }\n  } else if (isGateConfig(nameOrConfig)) {\n    mainConfig = nameOrConfig\n    defaultState = nameOrConfig.defaultState || {}\n    domain = nameOrConfig.domain\n  }\n  return {\n    hook,\n    domain,\n    defaultState,\n    mainConfig,\n    maybeConfig,\n  }\n}\n\nexport function createGate<Props>(...args: unknown[]): Gate<Props> {\n  return createGateImplementation<Props>(\n    processCreateGateConfig(useGateBase, args),\n  )\n}\n","export const throwError = (message: string) => {\n  throw Error(message)\n}\n","import React from 'react'\n\nexport const useIsomorphicLayoutEffect =\n  typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect\n","import {useEffect} from 'react'\n\nexport const useDeprecate = (\n  cond: boolean,\n  subject: string,\n  useInstead?: string,\n) => {\n  useEffect(() => {\n    if (cond) {\n      console.error(\n        `${subject} is deprecated${\n          useInstead ? `, prefer ${useInstead} instead` : ''\n        }`,\n      )\n    }\n  }, [cond, subject, useInstead])\n}\n","export const deprecate = (method: string, suggestion?: string) => {\n  const suggestionMessage = suggestion ? `, use ${suggestion} instead` : ''\n  console.error(`${method} is deprecated${suggestionMessage}`)\n}\n","import React from 'react'\n\nimport type {Store} from 'effector'\nimport {useStore} from './nossr'\nimport {withDisplayName} from './withDisplayName'\nimport {deprecate} from './deprecate'\n\nexport const connect = <State>(Component: React.ComponentType<any>) => {\n  deprecate('connect', 'useUnit')\n  return (store: Store<State>) => {\n    let View: any = Component\n    if (typeof Component !== 'function') {\n      View = store\n      store = Component as any\n    }\n    const wrappedComponentName = View.displayName || View.name || 'Unknown'\n    return withDisplayName(`Connect(${wrappedComponentName})`, (props: any) =>\n      React.createElement(View, {...props, ...useStore(store)}),\n    )\n  }\n}\n","export function forIn<T, Key extends string = string>(\n  obj: Record<Key, T>,\n  cb: (value: T, key: Key) => void,\n) {\n  for (const key in obj) {\n    cb(obj[key], key)\n  }\n}\n\nexport const includes = <T>(list: T[], item: T) => list.includes(item)\n\nexport const removeItem = <T>(list: T[], item: T) => {\n  const pos = list.indexOf(item)\n  if (pos !== -1) {\n    list.splice(pos, 1)\n  }\n}\n\nexport const add = <T>(list: T[], item: T) => list.push(item)\n\nexport function forEach<T>(\n  list: T[],\n  fn: (item: T, index: number, list: T[]) => void,\n): void\nexport function forEach<K, T>(\n  list: Map<K, T>,\n  fn: (item: T, key: K) => void,\n): void\nexport function forEach<T>(list: Set<T>, fn: (item: T) => void): void\nexport function forEach(list: any, fn: Function) {\n  list.forEach(fn)\n}\n"],"names":["withDisplayName","name","Component","displayName","useUnitBase","shape","scope","isSingleUnit","is","unit","normShape","throwError","isList","Array","isArray","flagsRef","React","useRef","stale","justSubscribed","eventsShape","storeKeys","storeValues","eventKeys","eventValues","useMemo","current","key","Object","hasOwnProperty","call","event","effect","scopeBind","push","keys","values","stateRef","value","subscribe","useCallback","cb","flags","createWatch","fn","batch","read","state","resultValue","changed","oldVal","oldStoreKeys","oldEventKeys","oldEventValues","scopeChanged","length","i","updatedValue","stateReader","includes","indexOf","useSyncExternalStore","useStoreMapBase","configOrStore","separateFn","defaultValue","store","updateFilter","basicUpdateFilter","valueRef","keysRef","useSyncExternalStoreWithSelector","a","b","isEqual","keysEqual","result","undefined","update","useGateBase","GateComponent","props","open","close","set","ForkedGate","propsRef","count","useIsomorphicLayoutEffect","aKeys","bKeys","shallowCompare","getScope","forceScope","useContext","ScopeContext","useEvent","opts","eventObject","useDeprecate","events","useEventBase","useStore","useStoreBase","useUnit","useStoreMap","useList","list","renderItem","getKey","placeholder","Item","shortName","index","keyVal","fnRef","item","memo","keysSelfMemo","listItems","map","createElement","from","_","useListBase","useGate","useProvidedScope","createComponent","renderProp","RenderComponent","mounted","getState","unmounted","deprecate","combine","storeName","createEvent","createStoreConsumer","children","processArgsToConfig","args","singleArgument","rawConfig","condition","Error","assert","isObject","isFunction","metadata","or","childConfig","and","unwrappedNestedValue","nested","processCreateGateConfig","hook","universalConfig","arg","nameOrConfig","defaultStateOrConfig","domain","defaultState","mainConfig","maybeConfig","config","isGateConfig","createGate","useGateHook","flattenConfig","fullName","compositeName","sid","status","createStore","Boolean","serialize","on","reset","hooks","launch","target","params","createGateImplementation","message","window","useLayoutEffect","useEffect","cond","subject","useInstead","console","error","upd","oldValue","createContext","Provider","method","suggestion","connect","View","part","obj","field","isVoid","forIn"],"mappings":"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"}