{"version":3,"file":"index.cjs","sources":["../src/utils.ts","../src/env.ts","../src/ScopeProvider/scope.ts","../src/ScopeProvider/ScopeProvider.tsx","../src/createIsolation.tsx"],"sourcesContent":["import type { AnyAtom, AnyWritableAtom } from './types'\n\nexport function isEqualSize(aIter: Iterable, bIter: Iterable) {\n const a = new Set(aIter)\n const b = new Set(bIter)\n return aIter === bIter || (a.size === b.size && Array.from(a).every(b.has.bind(b)))\n}\n\nexport function toNameString(this: { name: string }) {\n return this.name\n}\n\nexport function isWritableAtom(atom: AnyAtom): atom is AnyWritableAtom {\n return 'write' in atom\n}\n","export const __DEV__ =\n typeof import.meta !== 'undefined' && import.meta.env !== undefined && import.meta.env.MODE === 'development'\n ? true\n : process.env.NODE_ENV !== 'production'\n","import type { Atom, WritableAtom } from 'jotai'\nimport { atom as createAtom } from 'jotai'\nimport {\n INTERNAL_buildStoreRev2 as buildStore,\n INTERNAL_getBuildingBlocksRev2 as getBuildingBlocks,\n} from 'jotai/vanilla/internals'\nimport type {\n INTERNAL_AtomState as AtomState,\n INTERNAL_AtomStateMap as AtomStateMap,\n INTERNAL_BuildingBlocks as BuildingBlocks,\n INTERNAL_EnsureAtomState as EnsureAtomState,\n INTERNAL_Mounted as Mounted,\n INTERNAL_Store as Store,\n} from 'jotai/vanilla/internals'\nimport { __DEV__ } from '../env'\nimport type {\n AnyAtom,\n AnyAtomFamily,\n AnyWritableAtom,\n AtomPairMap,\n Scope,\n SetLike,\n StoreHookForAtoms,\n StoreHooks,\n WeakMapLike,\n} from '../types'\nimport { isWritableAtom, toNameString } from '../utils'\n\n/** WeakMap to store the scope associated with each scoped store */\nexport const storeScopeMap = new WeakMap()\n\nconst globalScopeKey: { name?: string } = {}\nif (__DEV__) {\n globalScopeKey.name = 'unscoped'\n globalScopeKey.toString = toNameString\n}\n\ntype GlobalScopeKey = typeof globalScopeKey\n\nconst { read: defaultRead, write: defaultWrite } = createAtom(null)\n\nexport function getAtom(scope: Scope, atom: Atom, implicitScope?: Scope): [Atom, Scope?] {\n const [explicitMap, implicitMap, inheritedSource, , parentScope] = scope\n\n const explicitEntry = explicitMap.get(atom)\n if (explicitEntry) {\n return explicitEntry\n }\n\n if (implicitScope === scope) {\n // dependencies of explicitly scoped atoms are implicitly scoped\n // implicitly scoped atoms are only accessed by implicit and explicit scoped atoms\n let implicitEntry = implicitMap.get(atom)\n if (!implicitEntry) {\n implicitEntry = [cloneAtom(scope, atom, implicitScope), implicitScope]\n implicitMap.set(atom, implicitEntry)\n }\n return implicitEntry\n }\n\n // inherited atoms are copied so they can access scoped atoms\n // dependencies of inherited atoms first check if they are explicitly scoped\n // otherwise they use their original scope's atom\n const source = implicitScope ?? globalScopeKey\n let inheritedMap = inheritedSource.get(source)\n if (!inheritedMap) {\n inheritedMap = new WeakMap() as AtomPairMap\n inheritedSource.set(source, inheritedMap)\n }\n let inheritedEntry = inheritedMap.get(atom)\n if (!inheritedEntry) {\n const [\n ancestorAtom,\n ancestorScope, //\n ] = parentScope ? getAtom(parentScope, atom, implicitScope) : [atom]\n const inheritedClone = atom.read === defaultRead ? ancestorAtom : cloneAtom(scope, atom, ancestorScope)\n inheritedEntry = [inheritedClone, ancestorScope]\n inheritedMap.set(atom, inheritedEntry)\n }\n return inheritedEntry\n}\n\nexport function cleanup(scope: Scope): void {\n for (const cleanupFamilyListeners of scope[5]) {\n cleanupFamilyListeners()\n }\n}\n\nexport function prepareWriteAtom(\n scope: Scope,\n atom: T,\n originalAtom: T,\n implicitScope: Scope | undefined,\n writeScope: Scope | undefined\n): (() => void) | undefined {\n if (\n originalAtom.read === defaultRead &&\n isWritableAtom(originalAtom) &&\n isWritableAtom(atom) &&\n originalAtom.write !== defaultWrite &&\n scope !== implicitScope\n ) {\n // atom is writable with init and holds a value\n // we need to preserve the value, so we don't want to copy the atom\n // instead, we need to override write until the write is finished\n const { write } = originalAtom\n atom.write = createScopedWrite(\n scope,\n originalAtom.write.bind(originalAtom) as (typeof originalAtom)['write'],\n implicitScope,\n writeScope\n )\n return () => {\n atom.write = write\n }\n }\n return undefined\n}\n\nfunction createScopedRead>(scope: Scope, read: T['read'], implicitScope?: Scope): T['read'] {\n return function scopedRead(get, opts) {\n return read(function scopedGet(a) {\n const [scopedAtom] = getAtom(scope, a, implicitScope)\n return get(scopedAtom)\n }, opts)\n }\n}\n\nfunction createScopedWrite(\n scope: Scope,\n write: T['write'],\n implicitScope?: Scope,\n writeScope = implicitScope\n): T['write'] {\n return function scopedWrite(get, set, ...args) {\n return write(\n function scopedGet(a) {\n const [scopedAtom] = getAtom(scope, a, implicitScope)\n return get(scopedAtom)\n },\n function scopedSet(a, ...v) {\n const [scopedAtom] = getAtom(scope, a, implicitScope)\n const restore = prepareWriteAtom(scope, scopedAtom, a, implicitScope, writeScope)\n try {\n return set(scopedAtom as typeof a, ...v)\n } finally {\n restore?.()\n }\n },\n ...args\n )\n }\n}\n\nfunction cloneAtom(scope: Scope, originalAtom: Atom, implicitScope: Scope | undefined): Atom {\n // avoid reading `init` to preserve lazy initialization\n const propDesc = Object.getOwnPropertyDescriptors(originalAtom)\n Object.keys(propDesc)\n .filter((k) => ['read', 'write', 'debugLabel'].includes(k))\n .forEach((k) => (propDesc[k].configurable = true))\n const atomProto = Object.getPrototypeOf(originalAtom)\n const scopedAtom: Atom = Object.create(atomProto, propDesc)\n\n if (scopedAtom.read !== defaultRead) {\n scopedAtom.read = createScopedRead(scope, originalAtom.read.bind(originalAtom), implicitScope)\n }\n\n if (isWritableAtom(scopedAtom) && isWritableAtom(originalAtom) && scopedAtom.write !== defaultWrite) {\n scopedAtom.write = createScopedWrite(scope, originalAtom.write.bind(originalAtom), implicitScope)\n }\n if (__DEV__) {\n Object.defineProperty(scopedAtom, 'debugLabel', {\n get() {\n return `${originalAtom.debugLabel}@${scope.name}`\n },\n configurable: true,\n enumerable: true,\n })\n }\n\n return scopedAtom\n}\n\ntype CreateScopeProps = {\n atoms?: Iterable\n atomFamilies?: Iterable\n parentStore: Store\n name?: string\n}\n\nexport function createScope({ atoms = [], atomFamilies = [], parentStore, name: scopeName }: CreateScopeProps): Store {\n const atomsSet = new WeakSet(atoms)\n const parentScope = storeScopeMap.get(parentStore)\n const baseStore = parentScope?.[3] ?? parentStore\n\n // Create the scope as an array with data fields\n const scope: Scope = [\n new WeakMap(),\n new WeakMap() as AtomPairMap,\n new WeakMap(),\n baseStore,\n parentScope,\n new Set<() => void>(),\n undefined!, // Store - will be set after creating patched store\n ] as Scope\n const explicitMap = scope[0]\n const cleanupFamiliesSet = scope[5]\n\n const scopedStore = createPatchedStore(scope)\n scope[6] = scopedStore\n Object.assign(scopedStore, { name: scopeName })\n storeScopeMap.set(scopedStore, scope)\n\n if (scopeName && __DEV__) {\n scope.name = scopeName\n scope.toString = toNameString\n }\n\n // populate explicitly scoped atoms\n for (const atom of new Set(atoms)) {\n explicitMap.set(atom, [cloneAtom(scope, atom, scope), scope])\n }\n\n for (const atomFamily of new Set(atomFamilies)) {\n for (const param of atomFamily.getParams()) {\n const atom = atomFamily(param)\n if (!explicitMap.has(atom)) {\n explicitMap.set(atom, [cloneAtom(scope, atom, scope), scope])\n }\n }\n const cleanupFamily = atomFamily.unstable_listen(({ type, atom }) => {\n if (type === 'CREATE' && !explicitMap.has(atom)) {\n explicitMap.set(atom, [cloneAtom(scope, atom, scope), scope])\n } else if (type === 'REMOVE' && !atomsSet.has(atom)) {\n explicitMap.delete(atom)\n }\n })\n cleanupFamiliesSet.add(cleanupFamily)\n }\n\n return scopedStore\n}\n\n/** @returns a patched store that intercepts atom access to apply the scope */\nfunction createPatchedStore(scope: Scope): Store {\n const baseStore = scope[3]\n const storeState: BuildingBlocks = [...getBuildingBlocks(baseStore)]\n const storeGet = storeState[21]\n const storeSet = storeState[22]\n const storeSub = storeState[23]\n const atomOnInit = storeState[9]\n const alreadyPatched: StoreHooks = {}\n\n storeState[9] = (_, atom) => atomOnInit(scopedStore, atom)\n storeState[21] = patchStoreFn(storeGet)\n storeState[22] = scopedSet\n storeState[23] = patchStoreFn(storeSub)\n storeState[24] = ([...buildingBlocks]) => {\n const patchedBuildingBlocks: BuildingBlocks = [\n patchWeakMap(buildingBlocks[0], patchGetAtomState), // atomStateMap\n patchWeakMap(buildingBlocks[1], patchGetMounted), // mountedMap\n patchWeakMap(buildingBlocks[2]), // invalidatedAtoms\n patchSet(buildingBlocks[3]), // changedAtoms\n buildingBlocks[4], // mountCallbacks\n buildingBlocks[5], // unmountCallbacks\n patchStoreHooks(buildingBlocks[6]), // storeHooks\n patchStoreFn(buildingBlocks[7]), // atomRead\n patchStoreFn(buildingBlocks[8]), // atomWrite\n buildingBlocks[9], // atomOnInit\n patchStoreFn(buildingBlocks[10]), // atomOnMount\n patchStoreFn(\n buildingBlocks[11], // ensureAtomState\n (fn) => patchEnsureAtomState(patchedBuildingBlocks[0], fn)\n ),\n buildingBlocks[12], // flushCallbacks\n buildingBlocks[13], // recomputeInvalidatedAtoms\n patchStoreFn(buildingBlocks[14]), // readAtomState\n patchStoreFn(buildingBlocks[15]), // invalidateDependents\n patchStoreFn(buildingBlocks[16]), // writeAtomState\n patchStoreFn(buildingBlocks[17]), // mountDependencies\n patchStoreFn(buildingBlocks[18]), // mountAtom\n patchStoreFn(buildingBlocks[19]), // unmountAtom\n patchStoreFn(buildingBlocks[20]), // setAtomStateValueOrPromise\n patchStoreFn(buildingBlocks[21]), // getAtom\n patchStoreFn(buildingBlocks[22]), // setAtom\n patchStoreFn(buildingBlocks[23]), // subAtom\n () => buildingBlocks, // enhanceBuildingBlocks (raw)\n ]\n return patchedBuildingBlocks\n }\n const scopedStore = buildStore(...storeState)\n return scopedStore\n\n // ---------------------------------------------------------------------------------\n\n function patchGetAtomState(fn: T) {\n const patchedASM = new WeakMap()\n return function patchedGetAtomState(atom) {\n let patchedAtomState = patchedASM.get(atom)\n if (patchedAtomState) {\n return patchedAtomState\n }\n const atomState = fn(atom)\n if (!atomState) {\n return undefined\n }\n patchedAtomState = {\n ...atomState,\n d: patchWeakMap(atomState.d, function patchGetDependency(fn) {\n return (k) => fn(getAtom(scope, k)[0])\n }),\n p: patchSet(atomState.p),\n get n() {\n return atomState.n\n },\n set n(v) {\n atomState.n = v\n },\n get v() {\n return atomState.v\n },\n set v(v) {\n atomState.v = v\n },\n get e() {\n return atomState.e\n },\n set e(v) {\n atomState.e = v\n },\n } as AtomState\n patchedASM.set(atom, patchedAtomState)\n return patchedAtomState\n } as T\n }\n\n function patchGetMounted(fn: T) {\n const patchedMM = new WeakMap()\n return function patchedGetMounted(atom: AnyAtom) {\n let patchedMounted = patchedMM.get(atom)\n if (patchedMounted) {\n return patchedMounted\n }\n const mounted = fn(atom)\n if (!mounted) {\n return undefined\n }\n patchedMounted = {\n ...mounted,\n d: patchSet(mounted.d),\n t: patchSet(mounted.t),\n get u() {\n return mounted.u\n },\n set u(v) {\n mounted.u = v\n },\n } as Mounted\n patchedMM.set(atom, patchedMounted)\n return patchedMounted\n } as T\n }\n\n function patchEnsureAtomState(patchedASM: AtomStateMap, fn: EnsureAtomState) {\n return function patchedEnsureAtomState(store, atom) {\n const patchedAtomState = patchedASM.get(atom)\n if (patchedAtomState) {\n return patchedAtomState\n }\n patchedASM.set(atom, fn(store, atom))\n return patchedASM.get(atom)\n } as EnsureAtomState\n }\n\n function scopedSet(\n store: Store,\n atom: WritableAtom,\n ...args: Args\n ): Result {\n const [scopedAtom, implicitScope] = getAtom(scope, atom)\n const restore = prepareWriteAtom(scope, scopedAtom, atom, implicitScope, scope)\n try {\n return storeSet(store, scopedAtom as typeof atom, ...args)\n } finally {\n restore?.()\n }\n }\n\n function patchAtomFn any>(fn: T, patch?: (fn: T) => T) {\n return function scopedAtomFn(atom, ...args) {\n const [scopedAtom] = getAtom(scope, atom)\n const f = patch ? patch(fn) : fn\n return f(scopedAtom, ...args)\n } as T\n }\n\n function patchStoreFn any>(fn: T, patch?: (fn: T) => T) {\n return function scopedStoreFn(store, atom, ...args) {\n const [scopedAtom] = getAtom(scope, atom)\n const f = patch ? patch(fn) : fn\n return f(store, scopedAtom, ...args)\n } as T\n }\n\n function patchWeakMap>(wm: T, patch?: (fn: T['get']) => T['get']): T {\n const patchedWm: WeakMapLike = {\n get: patchAtomFn(wm.get.bind(wm), patch),\n set: patchAtomFn(wm.set.bind(wm)),\n has: patchAtomFn(wm.has.bind(wm)),\n delete: patchAtomFn(wm.delete.bind(wm)),\n }\n return patchedWm as T\n }\n\n function patchSet(s: SetLike) {\n return {\n get size() {\n return s.size\n },\n add: patchAtomFn(s.add.bind(s)),\n has: patchAtomFn(s.has.bind(s)),\n delete: patchAtomFn(s.delete.bind(s)),\n clear: s.clear.bind(s),\n forEach: (cb) => s.forEach(patchAtomFn(cb)),\n *[Symbol.iterator](): IterableIterator {\n for (const atom of s) yield getAtom(scope, atom)[0]\n },\n } satisfies SetLike\n }\n\n function patchStoreHook(fn: StoreHookForAtoms | undefined) {\n if (!fn) {\n return undefined\n }\n const storeHook = patchAtomFn(fn)\n storeHook.add = function patchAdd(atom, callback) {\n if (atom === undefined) {\n return fn.add(undefined, callback)\n }\n const [scopedAtom] = getAtom(scope, atom)\n return fn.add(scopedAtom, callback as () => void)\n }\n return storeHook\n }\n\n function patchStoreHooks(storeHooks: StoreHooks) {\n const patchedStoreHooks: StoreHooks = {\n get f() {\n return storeHooks.f\n },\n set f(v) {\n storeHooks.f = v\n },\n }\n Object.defineProperties(\n patchedStoreHooks,\n Object.fromEntries(\n (['r', 'c', 'm', 'u'] as const).map((hook) => [\n hook,\n {\n get() {\n return (alreadyPatched[hook] ??= patchStoreHook(storeHooks[hook]))\n },\n set(value: StoreHookForAtoms | undefined) {\n delete alreadyPatched[hook]\n storeHooks[hook] = value\n },\n configurable: true,\n enumerable: true,\n },\n ])\n )\n )\n return Object.assign(patchedStoreHooks, storeHooks)\n }\n}\n","import type { ComponentType, PropsWithChildren, ReactNode } from 'react'\nimport { createElement, useEffect, useState } from 'react'\nimport { Provider, useStore } from 'jotai/react'\nimport { useHydrateAtoms } from 'jotai/utils'\nimport { INTERNAL_Store as Store } from 'jotai/vanilla/internals'\nimport type { AnyAtom, AnyAtomFamily, AtomDefault } from '../types'\nimport { isEqualSize } from '../utils'\nimport { cleanup, createScope, storeScopeMap } from './scope'\n\ntype BaseProps = PropsWithChildren<{\n atoms?: Iterable\n atomFamilies?: Iterable\n name?: string\n}>\n\ntype ProvidedScope = PropsWithChildren<{ scope: Store }>\n\ntype ProviderProps = { store: Store; children: ReactNode }\n\ntype ScopeProviderComponent = {\n (\n props: {\n atoms: Iterable\n } & BaseProps\n ): React.JSX.Element\n (\n props: {\n atomFamilies: Iterable\n } & BaseProps\n ): React.JSX.Element\n (props: PropsWithChildren<{ scope: Store }>): React.JSX.Element\n}\n\nexport function createScopeProvider(\n ProviderComponent: ComponentType,\n useStoreHook: typeof useStore\n): ScopeProviderComponent {\n return function ScopeProvider(props: BaseProps | ProvidedScope) {\n const {\n atoms: atomsOrTuples = [],\n atomFamilies = [],\n children,\n scope: providedScope,\n name,\n } = props as BaseProps & ProvidedScope\n const parentStore: Store = useStoreHook()\n const atoms = Array.from(atomsOrTuples, (a) => (Array.isArray(a) ? a[0] : a))\n\n function initialize() {\n return [\n providedScope ?? createScope({ atoms, atomFamilies, parentStore, name }),\n function hasChanged(current: {\n parentStore: Store\n atoms: Iterable\n atomFamilies: Iterable\n providedScope: Store | undefined\n }) {\n return (\n parentStore !== current.parentStore ||\n !isEqualSize(atoms, current.atoms) ||\n !isEqualSize(atomFamilies, current.atomFamilies) ||\n providedScope !== current.providedScope\n )\n },\n ] as const\n }\n\n const [[store, hasChanged], setState] = useState(initialize)\n if (hasChanged({ atoms, atomFamilies, parentStore, providedScope })) {\n const scope = storeScopeMap.get(store)\n if (scope) cleanup(scope)\n setState(initialize)\n }\n useHydrateAtoms(Array.from(atomsOrTuples).filter(Array.isArray) as AtomDefault[], { store })\n useEffect(() => {\n const scope = storeScopeMap.get(store)\n return () => {\n if (scope) cleanup(scope)\n }\n }, [store])\n return createElement(ProviderComponent, { store, children })\n } as ScopeProviderComponent\n}\n\nexport const ScopeProvider = createScopeProvider(Provider, useStore)\n","import { createContext, createElement, useContext, useRef } from 'react'\nimport type { ReactNode } from 'react'\nimport {\n useAtom as useAtomOrig,\n useAtomValue as useAtomValueOrig,\n useSetAtom as useSetAtomOrig,\n useStore as useStoreOrig,\n} from 'jotai/react'\nimport { useHydrateAtoms } from 'jotai/react/utils'\nimport { createStore } from 'jotai/vanilla'\nimport type { INTERNAL_Store as Store } from 'jotai/vanilla/internals'\nimport { createScopeProvider } from './ScopeProvider/ScopeProvider'\nimport type { AnyWritableAtom } from './types'\n\ntype CreateIsolationResult = {\n Provider: (props: {\n store?: Store\n initialValues?: Iterable\n children: ReactNode\n }) => React.JSX.Element\n ScopeProvider: ReturnType\n useStore: typeof useStoreOrig\n useAtom: typeof useAtomOrig\n useAtomValue: typeof useAtomValueOrig\n useSetAtom: typeof useSetAtomOrig\n}\n\nexport function createIsolation(): CreateIsolationResult {\n const StoreContext = createContext(null)\n\n function Provider({\n store,\n initialValues = [],\n children,\n }: {\n store?: Store\n initialValues?: Iterable\n children: ReactNode\n }) {\n const storeRef = useRef(store)\n if (!storeRef.current) {\n storeRef.current = createStore()\n }\n useHydrateAtoms(initialValues as any, { store: storeRef.current })\n return createElement(StoreContext.Provider, {\n value: storeRef.current,\n children,\n })\n }\n\n const useStore = ((options?: any) => {\n const store = useContext(StoreContext)\n if (!store) throw new Error('Missing Provider from createIsolation')\n return useStoreOrig({ store, ...options })\n }) as typeof useStoreOrig\n\n const useAtom = ((anAtom: any, options?: any) => {\n const store = useStore()\n return useAtomOrig(anAtom, { store, ...options })\n }) as typeof useAtomOrig\n\n const useAtomValue = ((anAtom: any, options?: any) => {\n const store = useStore()\n return useAtomValueOrig(anAtom, { store, ...options })\n }) as typeof useAtomValueOrig\n\n const useSetAtom = ((anAtom: any, options?: any) => {\n const store = useStore()\n return useSetAtomOrig(anAtom, { store, ...options })\n }) as typeof useSetAtomOrig\n\n const ScopeProvider = createScopeProvider(Provider, useStore)\n\n return {\n Provider,\n ScopeProvider,\n useStore,\n useAtom,\n useAtomValue,\n useSetAtom,\n }\n}\n"],"names":["isEqualSize","aIter","bIter","a","b","toNameString","isWritableAtom","atom","__DEV__","storeScopeMap","globalScopeKey","defaultRead","defaultWrite","createAtom","getAtom","scope","implicitScope","explicitMap","implicitMap","inheritedSource","parentScope","explicitEntry","implicitEntry","cloneAtom","source","inheritedMap","inheritedEntry","ancestorAtom","ancestorScope","cleanup","cleanupFamilyListeners","prepareWriteAtom","originalAtom","writeScope","write","createScopedWrite","createScopedRead","read","get","opts","scopedAtom","set","args","v","restore","propDesc","k","atomProto","createScope","atoms","atomFamilies","parentStore","scopeName","atomsSet","baseStore","cleanupFamiliesSet","scopedStore","createPatchedStore","atomFamily","param","cleanupFamily","type","storeState","getBuildingBlocks","storeGet","storeSet","storeSub","atomOnInit","alreadyPatched","_","patchStoreFn","scopedSet","patchedBuildingBlocks","patchWeakMap","buildingBlocks","patchGetAtomState","patchGetMounted","patchSet","patchStoreHooks","fn","patchEnsureAtomState","buildStore","patchedASM","patchedAtomState","atomState","patchedMM","patchedMounted","mounted","store","patchAtomFn","patch","wm","s","cb","patchStoreHook","storeHook","callback","storeHooks","patchedStoreHooks","hook","value","createScopeProvider","ProviderComponent","useStoreHook","props","atomsOrTuples","children","providedScope","name","initialize","current","hasChanged","setState","useState","useHydrateAtoms","useEffect","createElement","ScopeProvider","Provider","useStore","createIsolation","StoreContext","createContext","initialValues","storeRef","useRef","createStore","options","useContext","useStoreOrig","useAtom","anAtom","useAtomOrig","useAtomValue","useAtomValueOrig","useSetAtom","useSetAtomOrig"],"mappings":"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"}