@ariakit/store 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,23 @@
+# @ariakit/store
+
+## 0.1.0
+
+### Added standalone utility and store packages
+
+The shared utility and store helpers are now available as pure ESM packages with a single public entrypoint:
+
+```ts
+import { invariant } from "@ariakit/utils";
+import { createStore } from "@ariakit/store";
+import { useStoreState } from "@ariakit/react-store";
+```
+
+React consumers importing from `@ariakit/react` can continue to use `useStoreState` there. The standalone store packages are available for direct utility imports, and `@ariakit/react-components/store` exposes the React store helpers for component internals.
+
+### Other updates
+
+- Updated dependencies: `@ariakit/utils@0.1.0`
+
+## 0.0.0
+
+Initial release.

package/dist/index.d.ts

@@ -0,0 +1,78 @@
+import { AnyObject, SetStateAction } from "@ariakit/utils";
+
+//#region src/index.d.ts
+type Listener<S> = (state: S, prevState: S) => void | (() => void);
+type Sync<S, K extends keyof S> = (keys: K[] | null, listener: Listener<Pick<S, K>>) => () => void;
+type StoreSetup = (callback: () => void | (() => void)) => () => void;
+type StoreInit = () => () => void;
+type StoreSubscribe<S = State, K extends keyof S = keyof S> = Sync<S, K>;
+type StoreSync<S = State, K extends keyof S = keyof S> = Sync<S, K>;
+type StoreBatch<S = State, K extends keyof S = keyof S> = Sync<S, K>;
+type StorePick<S = State, K extends ReadonlyArray<keyof S> = ReadonlyArray<keyof S>> = (keys: K) => Store<Pick<S, K[number]>>;
+type StoreOmit<S = State, K extends ReadonlyArray<keyof S> = ReadonlyArray<keyof S>> = (keys: K) => Store<Omit<S, K[number]>>;
+/**
+ * Creates a store.
+ * @param initialState Initial state.
+ * @param stores Stores to extend.
+ */
+declare function createStore<S extends State>(initialState: S, ...stores: Array<Store<Partial<S>> | undefined>): Store<S>;
+declare function setup<T extends Store>(store?: T | null, ...args: Parameters<StoreSetup>): T extends Store ? ReturnType<StoreSetup> : void;
+declare function init<T extends Store>(store?: T | null, ...args: Parameters<StoreInit>): T extends Store ? ReturnType<StoreInit> : void;
+declare function subscribe<T extends Store, K extends keyof StoreState<T>>(store?: T | null, ...args: Parameters<StoreSubscribe<StoreState<T>, K>>): T extends Store ? ReturnType<StoreSubscribe<StoreState<T>, K>> : void;
+declare function sync<T extends Store, K extends keyof StoreState<T>>(store?: T | null, ...args: Parameters<StoreSync<StoreState<T>, K>>): T extends Store ? ReturnType<StoreSync<StoreState<T>, K>> : void;
+declare function batch<T extends Store, K extends keyof StoreState<T>>(store?: T | null, ...args: Parameters<StoreBatch<StoreState<T>, K>>): T extends Store ? ReturnType<StoreBatch<StoreState<T>, K>> : void;
+declare function omit<T extends Store, K extends ReadonlyArray<keyof StoreState<T>>>(store?: T | null, ...args: Parameters<StoreOmit<StoreState<T>, K>>): T extends Store ? ReturnType<StoreOmit<StoreState<T>, K>> : void;
+declare function pick<T extends Store, K extends ReadonlyArray<keyof StoreState<T>>>(store?: T | null, ...args: Parameters<StorePick<StoreState<T>, K>>): T extends Store ? ReturnType<StorePick<StoreState<T>, K>> : void;
+/**
+ * Merges multiple stores into a single store.
+ */
+declare function mergeStore<S extends State>(...stores: Array<Store<S> | undefined>): Store<S>;
+/**
+ * Throws when a store prop is passed in conjunction with a default state.
+ */
+declare function throwOnConflictingProps(props: AnyObject, store?: Store): void;
+/**
+ * Store state type.
+ */
+type State = AnyObject;
+/**
+ * Initial state that can be passed to a store creator function.
+ * @template S State type.
+ * @template K Key type.
+ */
+type StoreOptions<S extends State, K extends keyof S> = Partial<Pick<S, K>>;
+/**
+ * Props that can be passed to a store creator function.
+ * @template S State type.
+ */
+interface StoreProps<S extends State = State> {
+  /**
+   * Another store object that will be kept in sync with the original store.
+   *
+   * Live examples:
+   * - [Navigation Menubar](https://ariakit.com/examples/menubar-navigation)
+   */
+  store?: Store<Partial<S>>;
+}
+/**
+ * Extracts the state type from a store type.
+ * @template T Store type.
+ */
+type StoreState<T> = T extends Store<infer S> ? S : never;
+/**
+ * Store.
+ * @template S State type.
+ */
+interface Store<S = State> {
+  /**
+   * Returns the current store state.
+   */
+  getState(): S;
+  /**
+   * Sets a state value.
+   */
+  setState<K extends keyof S>(key: K, value: SetStateAction<S[K]>): void;
+}
+//#endregion
+export { State, Store, StoreOptions, StoreProps, StoreState, batch, createStore, init, mergeStore, omit, pick, setup, subscribe, sync, throwOnConflictingProps };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["AnyObject","SetStateAction","Listener","S","state","prevState","Sync","K","Pick","keys","listener","StoreSetup","callback","StoreInit","StoreSubscribe","State","StoreSync","StoreBatch","StorePick","ReadonlyArray","Store","StoreOmit","Omit","createStore","Partial","Array","initialState","stores","setup","T","Parameters","ReturnType","store","args","init","subscribe","StoreState","sync","batch","omit","pick","mergeStore","throwOnConflictingProps","props","StoreOptions","StoreProps","getState","setState","key","value"],"sources":["../src/index.d.ts"],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,216 @@
+import { applyState, chain, getKeys, hasOwnProperty, invariant, noop, omit as omit$1, pick as pick$1 } from "@ariakit/utils";
+//#region src/index.ts
+function getInternal(store, key) {
+	const internals = store.__unstableInternals;
+	invariant(internals, "Invalid store");
+	return internals[key];
+}
+/**
+* Creates a store.
+* @param initialState Initial state.
+* @param stores Stores to extend.
+*/
+function createStore(initialState, ...stores) {
+	let state = initialState;
+	let prevStateBatch = state;
+	let lastUpdate = Symbol();
+	let destroy = noop;
+	const instances = /* @__PURE__ */ new Set();
+	const updatedKeys = /* @__PURE__ */ new Set();
+	const setups = /* @__PURE__ */ new Set();
+	const listeners = /* @__PURE__ */ new Set();
+	const batchListeners = /* @__PURE__ */ new Set();
+	const disposables = /* @__PURE__ */ new WeakMap();
+	const listenerKeys = /* @__PURE__ */ new WeakMap();
+	const storeSetup = (callback) => {
+		setups.add(callback);
+		return () => setups.delete(callback);
+	};
+	const storeInit = () => {
+		const initialized = instances.size;
+		const instance = Symbol();
+		instances.add(instance);
+		const maybeDestroy = () => {
+			instances.delete(instance);
+			if (instances.size) return;
+			destroy();
+		};
+		if (initialized) return maybeDestroy;
+		const desyncs = getKeys(state).map((key) => chain(...stores.map((store) => {
+			const storeState = store?.getState?.();
+			if (!storeState) return;
+			if (!hasOwnProperty(storeState, key)) return;
+			return sync(store, [key], (state) => {
+				setState(key, state[key], true);
+			});
+		})));
+		const teardowns = [];
+		for (const setup of setups) teardowns.push(setup());
+		const cleanups = stores.map(init);
+		destroy = chain(...desyncs, ...teardowns, ...cleanups);
+		return maybeDestroy;
+	};
+	const sub = (keys, listener, set = listeners) => {
+		set.add(listener);
+		listenerKeys.set(listener, keys);
+		return () => {
+			disposables.get(listener)?.();
+			disposables.delete(listener);
+			listenerKeys.delete(listener);
+			set.delete(listener);
+		};
+	};
+	const storeSubscribe = (keys, listener) => sub(keys, listener);
+	const storeSync = (keys, listener) => {
+		disposables.set(listener, listener(state, state));
+		return sub(keys, listener);
+	};
+	const storeBatch = (keys, listener) => {
+		disposables.set(listener, listener(state, prevStateBatch));
+		return sub(keys, listener, batchListeners);
+	};
+	const storePick = (keys) => createStore(pick$1(state, keys), finalStore);
+	const storeOmit = (keys) => createStore(omit$1(state, keys), finalStore);
+	const getState = () => state;
+	const setState = (key, value, fromStores = false) => {
+		if (!hasOwnProperty(state, key)) return;
+		const nextValue = applyState(value, state[key]);
+		if (nextValue === state[key]) return;
+		if (!fromStores) for (const store of stores) store?.setState?.(key, nextValue);
+		const prevState = state;
+		state = {
+			...state,
+			[key]: nextValue
+		};
+		const thisUpdate = Symbol();
+		lastUpdate = thisUpdate;
+		updatedKeys.add(key);
+		const run = (listener, prev, uKeys) => {
+			const keys = listenerKeys.get(listener);
+			const updated = (k) => uKeys ? uKeys.has(k) : k === key;
+			if (!keys || keys.some(updated)) {
+				disposables.get(listener)?.();
+				disposables.set(listener, listener(state, prev));
+			}
+		};
+		for (const listener of listeners) run(listener, prevState);
+		queueMicrotask(() => {
+			if (lastUpdate !== thisUpdate) return;
+			const snapshot = state;
+			for (const listener of batchListeners) run(listener, prevStateBatch, updatedKeys);
+			prevStateBatch = snapshot;
+			updatedKeys.clear();
+		});
+	};
+	const finalStore = {
+		getState,
+		setState,
+		__unstableInternals: {
+			setup: storeSetup,
+			init: storeInit,
+			subscribe: storeSubscribe,
+			sync: storeSync,
+			batch: storeBatch,
+			pick: storePick,
+			omit: storeOmit
+		}
+	};
+	return finalStore;
+}
+/**
+* Register a callback function that's called when the store is initialized.
+*/
+function setup(store, ...args) {
+	if (!store) return;
+	return getInternal(store, "setup")(...args);
+}
+/**
+* Function that should be called when the store is initialized.
+*/
+function init(store, ...args) {
+	if (!store) return;
+	return getInternal(store, "init")(...args);
+}
+/**
+* Registers a listener function that's called after state changes in the store.
+*/
+function subscribe(store, ...args) {
+	if (!store) return;
+	return getInternal(store, "subscribe")(...args);
+}
+/**
+* Registers a listener function that's called immediately and synchronously
+* whenever the store state changes.
+*/
+function sync(store, ...args) {
+	if (!store) return;
+	return getInternal(store, "sync")(...args);
+}
+/**
+* Registers a listener function that's called immediately and after a batch
+* of state changes in the store.
+*/
+function batch(store, ...args) {
+	if (!store) return;
+	return getInternal(store, "batch")(...args);
+}
+/**
+* Creates a new store with a subset of the current store state and keeps them
+* in sync.
+*/
+function omit(store, ...args) {
+	if (!store) return;
+	return getInternal(store, "omit")(...args);
+}
+/**
+* Creates a new store with a subset of the current store state and keeps them
+* in sync.
+*/
+function pick(store, ...args) {
+	if (!store) return;
+	return getInternal(store, "pick")(...args);
+}
+/**
+* Merges multiple stores into a single store.
+*/
+function mergeStore(...stores) {
+	const initialState = {};
+	for (const store of stores) {
+		const nextState = store?.getState?.();
+		if (nextState) Object.assign(initialState, nextState);
+	}
+	const store = createStore(initialState, ...stores);
+	return Object.assign({}, ...stores, store);
+}
+/**
+* Throws when a store prop is passed in conjunction with a default state.
+*/
+function throwOnConflictingProps(props, store) {
+	if (!store) return;
+	const defaultKeys = Object.entries(props).filter(([key, value]) => key.startsWith("default") && value !== void 0).map(([key]) => {
+		const stateKey = key.replace("default", "");
+		return `${stateKey[0]?.toLowerCase() || ""}${stateKey.slice(1)}`;
+	});
+	if (!defaultKeys.length) return;
+	const storeState = store.getState();
+	if (!defaultKeys.filter((key) => hasOwnProperty(storeState, key)).length) return;
+	throw new Error(`Passing a store prop in conjunction with a default state is not supported.
+
+const store = useSelectStore();
+<SelectProvider store={store} defaultValue="Apple" />
+                ^             ^
+
+Instead, pass the default state to the topmost store:
+
+const store = useSelectStore({ defaultValue: "Apple" });
+<SelectProvider store={store} />
+
+See https://github.com/ariakit/ariakit/pull/2745 for more details.
+
+If there's a particular need for this, please submit a feature request at https://github.com/ariakit/ariakit
+`);
+}
+//#endregion
+export { batch, createStore, init, mergeStore, omit, pick, setup, subscribe, sync, throwOnConflictingProps };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_pick","_omit"],"sources":["../src/index.ts"],"sourcesContent":["import {\n  omit as _omit,\n  pick as _pick,\n  applyState,\n  chain,\n  getKeys,\n  hasOwnProperty,\n  invariant,\n  noop,\n} from \"@ariakit/utils\";\nimport type { AnyObject, SetStateAction } from \"@ariakit/utils\";\n\ntype Listener<S> = (state: S, prevState: S) => void | (() => void);\n\ntype Sync<S, K extends keyof S> = (\n  keys: K[] | null,\n  listener: Listener<Pick<S, K>>,\n) => () => void;\n\ntype StoreSetup = (callback: () => void | (() => void)) => () => void;\ntype StoreInit = () => () => void;\ntype StoreSubscribe<S = State, K extends keyof S = keyof S> = Sync<S, K>;\ntype StoreSync<S = State, K extends keyof S = keyof S> = Sync<S, K>;\ntype StoreBatch<S = State, K extends keyof S = keyof S> = Sync<S, K>;\ntype StorePick<\n  S = State,\n  K extends ReadonlyArray<keyof S> = ReadonlyArray<keyof S>,\n> = (keys: K) => Store<Pick<S, K[number]>>;\ntype StoreOmit<\n  S = State,\n  K extends ReadonlyArray<keyof S> = ReadonlyArray<keyof S>,\n> = (keys: K) => Store<Omit<S, K[number]>>;\n\ninterface StoreInternals<S = State> {\n  setup: StoreSetup;\n  init: StoreInit;\n  subscribe: StoreSubscribe<S>;\n  sync: StoreSync<S>;\n  batch: StoreBatch<S>;\n  pick: StorePick<S>;\n  omit: StoreOmit<S>;\n}\n\nfunction getInternal<K extends keyof StoreInternals>(\n  store: Store & { __unstableInternals?: StoreInternals },\n  key: K,\n): StoreInternals[K] {\n  const internals = store.__unstableInternals;\n  invariant(internals, \"Invalid store\");\n  return internals[key];\n}\n\n/**\n * Creates a store.\n * @param initialState Initial state.\n * @param stores Stores to extend.\n */\nexport function createStore<S extends State>(\n  initialState: S,\n  ...stores: Array<Store<Partial<S>> | undefined>\n): Store<S> {\n  let state = initialState;\n  let prevStateBatch = state;\n  let lastUpdate = Symbol();\n  let destroy = noop;\n  const instances = new Set<symbol>();\n  const updatedKeys = new Set<keyof S>();\n\n  const setups = new Set<() => void | (() => void)>();\n  const listeners = new Set<Listener<S>>();\n  const batchListeners = new Set<Listener<S>>();\n  const disposables = new WeakMap<Listener<S>, void | (() => void)>();\n  const listenerKeys = new WeakMap<Listener<S>, Array<keyof S> | null>();\n\n  const storeSetup: StoreSetup = (callback) => {\n    setups.add(callback);\n    return () => setups.delete(callback);\n  };\n\n  const storeInit: StoreInit = () => {\n    // Make sure we only initialize the store once, even when it's passed to\n    // other stores. However, the store can't be destroyed until all instances\n    // are unmounted. See https://github.com/ariakit/ariakit/issues/3147. See\n    // select-default-open-controlled tests.\n    const initialized = instances.size;\n    const instance = Symbol();\n    instances.add(instance);\n\n    const maybeDestroy = () => {\n      instances.delete(instance);\n      if (instances.size) return;\n      destroy();\n    };\n\n    if (initialized) return maybeDestroy;\n\n    const desyncs = getKeys(state).map((key) =>\n      chain(\n        ...stores.map((store) => {\n          const storeState = store?.getState?.();\n          if (!storeState) return;\n          if (!hasOwnProperty(storeState, key)) return;\n          return sync(store, [key], (state) => {\n            setState(\n              key,\n              state[key],\n              // @ts-expect-error - Not public API. This is just to prevent\n              // infinite loops.\n              true,\n            );\n          });\n        }),\n      ),\n    );\n\n    const teardowns: Array<void | (() => void)> = [];\n    for (const setup of setups) {\n      teardowns.push(setup());\n    }\n\n    const cleanups = stores.map(init);\n\n    destroy = chain(...desyncs, ...teardowns, ...cleanups);\n\n    return maybeDestroy;\n  };\n\n  const sub = (\n    keys: Array<keyof S> | null,\n    listener: Listener<S>,\n    set = listeners,\n  ) => {\n    set.add(listener);\n    listenerKeys.set(listener, keys);\n    return () => {\n      disposables.get(listener)?.();\n      disposables.delete(listener);\n      listenerKeys.delete(listener);\n      set.delete(listener);\n    };\n  };\n\n  const storeSubscribe: StoreSubscribe<S> = (keys, listener) =>\n    sub(keys, listener);\n\n  const storeSync: StoreSync<S> = (keys, listener) => {\n    disposables.set(listener, listener(state, state));\n    return sub(keys, listener);\n  };\n\n  const storeBatch: StoreBatch<S> = (keys, listener) => {\n    disposables.set(listener, listener(state, prevStateBatch));\n    return sub(keys, listener, batchListeners);\n  };\n\n  const storePick: StorePick<S, ReadonlyArray<keyof S>> = (keys) =>\n    createStore(_pick(state, keys), finalStore);\n\n  const storeOmit: StoreOmit<S, ReadonlyArray<keyof S>> = (keys) =>\n    createStore(_omit(state, keys), finalStore);\n\n  const getState: Store<S>[\"getState\"] = () => state;\n\n  const setState: Store<S>[\"setState\"] = (key, value, fromStores = false) => {\n    if (!hasOwnProperty(state, key)) return;\n\n    const nextValue = applyState(value, state[key]);\n\n    if (nextValue === state[key]) return;\n\n    if (!fromStores) {\n      for (const store of stores) {\n        store?.setState?.(key, nextValue);\n      }\n    }\n\n    const prevState = state;\n    state = { ...state, [key]: nextValue };\n\n    const thisUpdate = Symbol();\n    lastUpdate = thisUpdate;\n    updatedKeys.add(key);\n\n    const run = (listener: Listener<S>, prev: S, uKeys?: Set<keyof S>) => {\n      const keys = listenerKeys.get(listener);\n      const updated = (k: keyof S) => (uKeys ? uKeys.has(k) : k === key);\n      if (!keys || keys.some(updated)) {\n        disposables.get(listener)?.();\n        disposables.set(listener, listener(state, prev));\n      }\n    };\n\n    for (const listener of listeners) {\n      run(listener, prevState);\n    }\n\n    queueMicrotask(() => {\n      // If setState is called again before this microtask runs, skip this\n      // update. This is to prevent unnecessary updates when multiple keys are\n      // updated in a single microtask.\n      if (lastUpdate !== thisUpdate) return;\n      // Take a snapshot of the state before running batch listeners. This is\n      // necessary because batch listeners can setState.\n      const snapshot = state;\n      for (const listener of batchListeners) {\n        run(listener, prevStateBatch, updatedKeys);\n      }\n      prevStateBatch = snapshot;\n      updatedKeys.clear();\n    });\n  };\n\n  const finalStore = {\n    getState,\n    setState,\n    __unstableInternals: {\n      setup: storeSetup,\n      init: storeInit,\n      subscribe: storeSubscribe,\n      sync: storeSync,\n      batch: storeBatch,\n      pick: storePick,\n      omit: storeOmit,\n    },\n  };\n\n  return finalStore;\n}\n\nexport function setup<T extends Store>(\n  store?: T | null,\n  ...args: Parameters<StoreSetup>\n): T extends Store ? ReturnType<StoreSetup> : void;\n\n/**\n * Register a callback function that's called when the store is initialized.\n */\nexport function setup(store?: Store, ...args: Parameters<StoreSetup>) {\n  if (!store) return;\n  return getInternal(store, \"setup\")(...args);\n}\n\nexport function init<T extends Store>(\n  store?: T | null,\n  ...args: Parameters<StoreInit>\n): T extends Store ? ReturnType<StoreInit> : void;\n\n/**\n * Function that should be called when the store is initialized.\n */\nexport function init(store?: Store, ...args: Parameters<StoreInit>) {\n  if (!store) return;\n  return getInternal(store, \"init\")(...args);\n}\n\nexport function subscribe<T extends Store, K extends keyof StoreState<T>>(\n  store?: T | null,\n  ...args: Parameters<StoreSubscribe<StoreState<T>, K>>\n): T extends Store ? ReturnType<StoreSubscribe<StoreState<T>, K>> : void;\n\n/**\n * Registers a listener function that's called after state changes in the store.\n */\nexport function subscribe(store?: Store, ...args: Parameters<StoreSubscribe>) {\n  if (!store) return;\n  return getInternal(store, \"subscribe\")(...args);\n}\n\nexport function sync<T extends Store, K extends keyof StoreState<T>>(\n  store?: T | null,\n  ...args: Parameters<StoreSync<StoreState<T>, K>>\n): T extends Store ? ReturnType<StoreSync<StoreState<T>, K>> : void;\n\n/**\n * Registers a listener function that's called immediately and synchronously\n * whenever the store state changes.\n */\nexport function sync(store?: Store, ...args: Parameters<StoreSync>) {\n  if (!store) return;\n  return getInternal(store, \"sync\")(...args);\n}\n\nexport function batch<T extends Store, K extends keyof StoreState<T>>(\n  store?: T | null,\n  ...args: Parameters<StoreBatch<StoreState<T>, K>>\n): T extends Store ? ReturnType<StoreBatch<StoreState<T>, K>> : void;\n\n/**\n * Registers a listener function that's called immediately and after a batch\n * of state changes in the store.\n */\nexport function batch(store?: Store, ...args: Parameters<StoreBatch>) {\n  if (!store) return;\n  return getInternal(store, \"batch\")(...args);\n}\n\nexport function omit<\n  T extends Store,\n  K extends ReadonlyArray<keyof StoreState<T>>,\n>(\n  store?: T | null,\n  ...args: Parameters<StoreOmit<StoreState<T>, K>>\n): T extends Store ? ReturnType<StoreOmit<StoreState<T>, K>> : void;\n\n/**\n * Creates a new store with a subset of the current store state and keeps them\n * in sync.\n */\nexport function omit(store?: Store, ...args: Parameters<StoreOmit>) {\n  if (!store) return;\n  return getInternal(store, \"omit\")(...args);\n}\n\nexport function pick<\n  T extends Store,\n  K extends ReadonlyArray<keyof StoreState<T>>,\n>(\n  store?: T | null,\n  ...args: Parameters<StorePick<StoreState<T>, K>>\n): T extends Store ? ReturnType<StorePick<StoreState<T>, K>> : void;\n\n/**\n * Creates a new store with a subset of the current store state and keeps them\n * in sync.\n */\nexport function pick(store: Store, ...args: Parameters<StorePick>) {\n  if (!store) return;\n  return getInternal(store, \"pick\")(...args);\n}\n\n/**\n * Merges multiple stores into a single store.\n */\nexport function mergeStore<S extends State>(\n  ...stores: Array<Store<S> | undefined>\n): Store<S> {\n  const initialState = {} as S;\n  for (const store of stores) {\n    const nextState = store?.getState?.();\n    if (nextState) {\n      Object.assign(initialState, nextState);\n    }\n  }\n  const store = createStore(initialState, ...stores);\n  return Object.assign({}, ...stores, store);\n}\n\n/**\n * Throws when a store prop is passed in conjunction with a default state.\n */\nexport function throwOnConflictingProps(props: AnyObject, store?: Store) {\n  if (process.env.NODE_ENV === \"production\") return;\n  if (!store) return;\n  const defaultKeys = Object.entries(props)\n    .filter(([key, value]) => key.startsWith(\"default\") && value !== undefined)\n    .map(([key]) => {\n      const stateKey = key.replace(\"default\", \"\");\n      return `${stateKey[0]?.toLowerCase() || \"\"}${stateKey.slice(1)}`;\n    });\n  if (!defaultKeys.length) return;\n  const storeState = store.getState();\n  const conflictingProps = defaultKeys.filter((key) =>\n    hasOwnProperty(storeState, key),\n  );\n  if (!conflictingProps.length) return;\n  throw new Error(\n    `Passing a store prop in conjunction with a default state is not supported.\n\nconst store = useSelectStore();\n<SelectProvider store={store} defaultValue=\"Apple\" />\n                ^             ^\n\nInstead, pass the default state to the topmost store:\n\nconst store = useSelectStore({ defaultValue: \"Apple\" });\n<SelectProvider store={store} />\n\nSee https://github.com/ariakit/ariakit/pull/2745 for more details.\n\nIf there's a particular need for this, please submit a feature request at https://github.com/ariakit/ariakit\n`,\n  );\n}\n\n/**\n * Store state type.\n */\nexport type State = AnyObject;\n\n/**\n * Initial state that can be passed to a store creator function.\n * @template S State type.\n * @template K Key type.\n */\nexport type StoreOptions<S extends State, K extends keyof S> = Partial<\n  Pick<S, K>\n>;\n\n/**\n * Props that can be passed to a store creator function.\n * @template S State type.\n */\nexport interface StoreProps<S extends State = State> {\n  /**\n   * Another store object that will be kept in sync with the original store.\n   *\n   * Live examples:\n   * - [Navigation Menubar](https://ariakit.com/examples/menubar-navigation)\n   */\n  store?: Store<Partial<S>>;\n}\n\n/**\n * Extracts the state type from a store type.\n * @template T Store type.\n */\nexport type StoreState<T> = T extends Store<infer S> ? S : never;\n\n/**\n * Store.\n * @template S State type.\n */\nexport interface Store<S = State> {\n  /**\n   * Returns the current store state.\n   */\n  getState(): S;\n  /**\n   * Sets a state value.\n   */\n  setState<K extends keyof S>(key: K, value: SetStateAction<S[K]>): void;\n}\n"],"mappings":"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"}

package/license

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present Ariakit FZ-LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@ariakit/store",
+  "version": "0.1.0",
+  "description": "Ariakit store utilities",
+  "keywords": [
+    "ariakit",
+    "store"
+  ],
+  "homepage": "https://ariakit.com",
+  "license": "MIT",
+  "author": {
+    "name": "Diego Haz",
+    "email": "hazdiego@gmail.com",
+    "url": "https://github.com/diegohaz"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ariakit/ariakit.git",
+    "directory": "packages/ariakit-store"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "dependencies": {
+    "@ariakit/utils": "0.1.0"
+  },
+  "devDependencies": {
+    "@ariakit/scripts": "0.0.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "ariakit build --index-only",
+    "clean": "ariakit clean"
+  }
+}

package/readme.md

@@ -0,0 +1,17 @@
+# @ariakit/store
+
+**Important:** This package is experimental and does not follow semantic versioning, meaning breaking changes may occur in patch and minor versions.
+
+Framework-agnostic store primitives used by Ariakit packages.
+
+```sh
+npm i @ariakit/store
+```
+
+Import store helpers from the package root:
+
+```ts
+import { createStore } from "@ariakit/store";
+```
+
+This package is ESM-only and exposes a single public entrypoint.

package/src/index.ts

@@ -0,0 +1,432 @@
+import {
+  omit as _omit,
+  pick as _pick,
+  applyState,
+  chain,
+  getKeys,
+  hasOwnProperty,
+  invariant,
+  noop,
+} from "@ariakit/utils";
+import type { AnyObject, SetStateAction } from "@ariakit/utils";
+
+type Listener<S> = (state: S, prevState: S) => void | (() => void);
+
+type Sync<S, K extends keyof S> = (
+  keys: K[] | null,
+  listener: Listener<Pick<S, K>>,
+) => () => void;
+
+type StoreSetup = (callback: () => void | (() => void)) => () => void;
+type StoreInit = () => () => void;
+type StoreSubscribe<S = State, K extends keyof S = keyof S> = Sync<S, K>;
+type StoreSync<S = State, K extends keyof S = keyof S> = Sync<S, K>;
+type StoreBatch<S = State, K extends keyof S = keyof S> = Sync<S, K>;
+type StorePick<
+  S = State,
+  K extends ReadonlyArray<keyof S> = ReadonlyArray<keyof S>,
+> = (keys: K) => Store<Pick<S, K[number]>>;
+type StoreOmit<
+  S = State,
+  K extends ReadonlyArray<keyof S> = ReadonlyArray<keyof S>,
+> = (keys: K) => Store<Omit<S, K[number]>>;
+
+interface StoreInternals<S = State> {
+  setup: StoreSetup;
+  init: StoreInit;
+  subscribe: StoreSubscribe<S>;
+  sync: StoreSync<S>;
+  batch: StoreBatch<S>;
+  pick: StorePick<S>;
+  omit: StoreOmit<S>;
+}
+
+function getInternal<K extends keyof StoreInternals>(
+  store: Store & { __unstableInternals?: StoreInternals },
+  key: K,
+): StoreInternals[K] {
+  const internals = store.__unstableInternals;
+  invariant(internals, "Invalid store");
+  return internals[key];
+}
+
+/**
+ * Creates a store.
+ * @param initialState Initial state.
+ * @param stores Stores to extend.
+ */
+export function createStore<S extends State>(
+  initialState: S,
+  ...stores: Array<Store<Partial<S>> | undefined>
+): Store<S> {
+  let state = initialState;
+  let prevStateBatch = state;
+  let lastUpdate = Symbol();
+  let destroy = noop;
+  const instances = new Set<symbol>();
+  const updatedKeys = new Set<keyof S>();
+
+  const setups = new Set<() => void | (() => void)>();
+  const listeners = new Set<Listener<S>>();
+  const batchListeners = new Set<Listener<S>>();
+  const disposables = new WeakMap<Listener<S>, void | (() => void)>();
+  const listenerKeys = new WeakMap<Listener<S>, Array<keyof S> | null>();
+
+  const storeSetup: StoreSetup = (callback) => {
+    setups.add(callback);
+    return () => setups.delete(callback);
+  };
+
+  const storeInit: StoreInit = () => {
+    // Make sure we only initialize the store once, even when it's passed to
+    // other stores. However, the store can't be destroyed until all instances
+    // are unmounted. See https://github.com/ariakit/ariakit/issues/3147. See
+    // select-default-open-controlled tests.
+    const initialized = instances.size;
+    const instance = Symbol();
+    instances.add(instance);
+
+    const maybeDestroy = () => {
+      instances.delete(instance);
+      if (instances.size) return;
+      destroy();
+    };
+
+    if (initialized) return maybeDestroy;
+
+    const desyncs = getKeys(state).map((key) =>
+      chain(
+        ...stores.map((store) => {
+          const storeState = store?.getState?.();
+          if (!storeState) return;
+          if (!hasOwnProperty(storeState, key)) return;
+          return sync(store, [key], (state) => {
+            setState(
+              key,
+              state[key],
+              // @ts-expect-error - Not public API. This is just to prevent
+              // infinite loops.
+              true,
+            );
+          });
+        }),
+      ),
+    );
+
+    const teardowns: Array<void | (() => void)> = [];
+    for (const setup of setups) {
+      teardowns.push(setup());
+    }
+
+    const cleanups = stores.map(init);
+
+    destroy = chain(...desyncs, ...teardowns, ...cleanups);
+
+    return maybeDestroy;
+  };
+
+  const sub = (
+    keys: Array<keyof S> | null,
+    listener: Listener<S>,
+    set = listeners,
+  ) => {
+    set.add(listener);
+    listenerKeys.set(listener, keys);
+    return () => {
+      disposables.get(listener)?.();
+      disposables.delete(listener);
+      listenerKeys.delete(listener);
+      set.delete(listener);
+    };
+  };
+
+  const storeSubscribe: StoreSubscribe<S> = (keys, listener) =>
+    sub(keys, listener);
+
+  const storeSync: StoreSync<S> = (keys, listener) => {
+    disposables.set(listener, listener(state, state));
+    return sub(keys, listener);
+  };
+
+  const storeBatch: StoreBatch<S> = (keys, listener) => {
+    disposables.set(listener, listener(state, prevStateBatch));
+    return sub(keys, listener, batchListeners);
+  };
+
+  const storePick: StorePick<S, ReadonlyArray<keyof S>> = (keys) =>
+    createStore(_pick(state, keys), finalStore);
+
+  const storeOmit: StoreOmit<S, ReadonlyArray<keyof S>> = (keys) =>
+    createStore(_omit(state, keys), finalStore);
+
+  const getState: Store<S>["getState"] = () => state;
+
+  const setState: Store<S>["setState"] = (key, value, fromStores = false) => {
+    if (!hasOwnProperty(state, key)) return;
+
+    const nextValue = applyState(value, state[key]);
+
+    if (nextValue === state[key]) return;
+
+    if (!fromStores) {
+      for (const store of stores) {
+        store?.setState?.(key, nextValue);
+      }
+    }
+
+    const prevState = state;
+    state = { ...state, [key]: nextValue };
+
+    const thisUpdate = Symbol();
+    lastUpdate = thisUpdate;
+    updatedKeys.add(key);
+
+    const run = (listener: Listener<S>, prev: S, uKeys?: Set<keyof S>) => {
+      const keys = listenerKeys.get(listener);
+      const updated = (k: keyof S) => (uKeys ? uKeys.has(k) : k === key);
+      if (!keys || keys.some(updated)) {
+        disposables.get(listener)?.();
+        disposables.set(listener, listener(state, prev));
+      }
+    };
+
+    for (const listener of listeners) {
+      run(listener, prevState);
+    }
+
+    queueMicrotask(() => {
+      // If setState is called again before this microtask runs, skip this
+      // update. This is to prevent unnecessary updates when multiple keys are
+      // updated in a single microtask.
+      if (lastUpdate !== thisUpdate) return;
+      // Take a snapshot of the state before running batch listeners. This is
+      // necessary because batch listeners can setState.
+      const snapshot = state;
+      for (const listener of batchListeners) {
+        run(listener, prevStateBatch, updatedKeys);
+      }
+      prevStateBatch = snapshot;
+      updatedKeys.clear();
+    });
+  };
+
+  const finalStore = {
+    getState,
+    setState,
+    __unstableInternals: {
+      setup: storeSetup,
+      init: storeInit,
+      subscribe: storeSubscribe,
+      sync: storeSync,
+      batch: storeBatch,
+      pick: storePick,
+      omit: storeOmit,
+    },
+  };
+
+  return finalStore;
+}
+
+export function setup<T extends Store>(
+  store?: T | null,
+  ...args: Parameters<StoreSetup>
+): T extends Store ? ReturnType<StoreSetup> : void;
+
+/**
+ * Register a callback function that's called when the store is initialized.
+ */
+export function setup(store?: Store, ...args: Parameters<StoreSetup>) {
+  if (!store) return;
+  return getInternal(store, "setup")(...args);
+}
+
+export function init<T extends Store>(
+  store?: T | null,
+  ...args: Parameters<StoreInit>
+): T extends Store ? ReturnType<StoreInit> : void;
+
+/**
+ * Function that should be called when the store is initialized.
+ */
+export function init(store?: Store, ...args: Parameters<StoreInit>) {
+  if (!store) return;
+  return getInternal(store, "init")(...args);
+}
+
+export function subscribe<T extends Store, K extends keyof StoreState<T>>(
+  store?: T | null,
+  ...args: Parameters<StoreSubscribe<StoreState<T>, K>>
+): T extends Store ? ReturnType<StoreSubscribe<StoreState<T>, K>> : void;
+
+/**
+ * Registers a listener function that's called after state changes in the store.
+ */
+export function subscribe(store?: Store, ...args: Parameters<StoreSubscribe>) {
+  if (!store) return;
+  return getInternal(store, "subscribe")(...args);
+}
+
+export function sync<T extends Store, K extends keyof StoreState<T>>(
+  store?: T | null,
+  ...args: Parameters<StoreSync<StoreState<T>, K>>
+): T extends Store ? ReturnType<StoreSync<StoreState<T>, K>> : void;
+
+/**
+ * Registers a listener function that's called immediately and synchronously
+ * whenever the store state changes.
+ */
+export function sync(store?: Store, ...args: Parameters<StoreSync>) {
+  if (!store) return;
+  return getInternal(store, "sync")(...args);
+}
+
+export function batch<T extends Store, K extends keyof StoreState<T>>(
+  store?: T | null,
+  ...args: Parameters<StoreBatch<StoreState<T>, K>>
+): T extends Store ? ReturnType<StoreBatch<StoreState<T>, K>> : void;
+
+/**
+ * Registers a listener function that's called immediately and after a batch
+ * of state changes in the store.
+ */
+export function batch(store?: Store, ...args: Parameters<StoreBatch>) {
+  if (!store) return;
+  return getInternal(store, "batch")(...args);
+}
+
+export function omit<
+  T extends Store,
+  K extends ReadonlyArray<keyof StoreState<T>>,
+>(
+  store?: T | null,
+  ...args: Parameters<StoreOmit<StoreState<T>, K>>
+): T extends Store ? ReturnType<StoreOmit<StoreState<T>, K>> : void;
+
+/**
+ * Creates a new store with a subset of the current store state and keeps them
+ * in sync.
+ */
+export function omit(store?: Store, ...args: Parameters<StoreOmit>) {
+  if (!store) return;
+  return getInternal(store, "omit")(...args);
+}
+
+export function pick<
+  T extends Store,
+  K extends ReadonlyArray<keyof StoreState<T>>,
+>(
+  store?: T | null,
+  ...args: Parameters<StorePick<StoreState<T>, K>>
+): T extends Store ? ReturnType<StorePick<StoreState<T>, K>> : void;
+
+/**
+ * Creates a new store with a subset of the current store state and keeps them
+ * in sync.
+ */
+export function pick(store: Store, ...args: Parameters<StorePick>) {
+  if (!store) return;
+  return getInternal(store, "pick")(...args);
+}
+
+/**
+ * Merges multiple stores into a single store.
+ */
+export function mergeStore<S extends State>(
+  ...stores: Array<Store<S> | undefined>
+): Store<S> {
+  const initialState = {} as S;
+  for (const store of stores) {
+    const nextState = store?.getState?.();
+    if (nextState) {
+      Object.assign(initialState, nextState);
+    }
+  }
+  const store = createStore(initialState, ...stores);
+  return Object.assign({}, ...stores, store);
+}
+
+/**
+ * Throws when a store prop is passed in conjunction with a default state.
+ */
+export function throwOnConflictingProps(props: AnyObject, store?: Store) {
+  if (process.env.NODE_ENV === "production") return;
+  if (!store) return;
+  const defaultKeys = Object.entries(props)
+    .filter(([key, value]) => key.startsWith("default") && value !== undefined)
+    .map(([key]) => {
+      const stateKey = key.replace("default", "");
+      return `${stateKey[0]?.toLowerCase() || ""}${stateKey.slice(1)}`;
+    });
+  if (!defaultKeys.length) return;
+  const storeState = store.getState();
+  const conflictingProps = defaultKeys.filter((key) =>
+    hasOwnProperty(storeState, key),
+  );
+  if (!conflictingProps.length) return;
+  throw new Error(
+    `Passing a store prop in conjunction with a default state is not supported.
+
+const store = useSelectStore();
+<SelectProvider store={store} defaultValue="Apple" />
+                ^             ^
+
+Instead, pass the default state to the topmost store:
+
+const store = useSelectStore({ defaultValue: "Apple" });
+<SelectProvider store={store} />
+
+See https://github.com/ariakit/ariakit/pull/2745 for more details.
+
+If there's a particular need for this, please submit a feature request at https://github.com/ariakit/ariakit
+`,
+  );
+}
+
+/**
+ * Store state type.
+ */
+export type State = AnyObject;
+
+/**
+ * Initial state that can be passed to a store creator function.
+ * @template S State type.
+ * @template K Key type.
+ */
+export type StoreOptions<S extends State, K extends keyof S> = Partial<
+  Pick<S, K>
+>;
+
+/**
+ * Props that can be passed to a store creator function.
+ * @template S State type.
+ */
+export interface StoreProps<S extends State = State> {
+  /**
+   * Another store object that will be kept in sync with the original store.
+   *
+   * Live examples:
+   * - [Navigation Menubar](https://ariakit.com/examples/menubar-navigation)
+   */
+  store?: Store<Partial<S>>;
+}
+
+/**
+ * Extracts the state type from a store type.
+ * @template T Store type.
+ */
+export type StoreState<T> = T extends Store<infer S> ? S : never;
+
+/**
+ * Store.
+ * @template S State type.
+ */
+export interface Store<S = State> {
+  /**
+   * Returns the current store state.
+   */
+  getState(): S;
+  /**
+   * Sets a state value.
+   */
+  setState<K extends keyof S>(key: K, value: SetStateAction<S[K]>): void;
+}