cross-state 0.6.0

package/dist/es/react.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.mjs","sources":["../../src/react/storeScope.tsx","../../node_modules/.pnpm/use-sync-external-store@1.2.0_react@18.2.0/node_modules/use-sync-external-store/cjs/use-sync-external-store-with-selector.production.min.js","../../node_modules/.pnpm/use-sync-external-store@1.2.0_react@18.2.0/node_modules/use-sync-external-store/cjs/use-sync-external-store-with-selector.development.js","../../node_modules/.pnpm/use-sync-external-store@1.2.0_react@18.2.0/node_modules/use-sync-external-store/with-selector.js","../../src/react/useStore.ts","../../src/react/useProp.ts"],"sourcesContent":["import type { Store } from '@core/store';\nimport { store } from '@core/store';\nimport type { StoreScope } from '@core/storeScope';\nimport type { Context, ReactNode } from 'react';\nimport { createContext, useContext, useMemo } from 'react';\n\nexport type StoreScopeProps<T> = { scope: StoreScope<T>; store?: Store<T>; children?: ReactNode };\n\nexport const contextMap = new WeakMap<StoreScope<any>, Context<Store<any>>>();\n\nexport function getStoreScopeContext<T>(scope: StoreScope<T>): Context<Store<T>> {\n  let context = contextMap.get(scope);\n\n  if (!context) {\n    context = createContext<Store<T>>(store(scope.defaultValue));\n    contextMap.set(scope, context);\n  }\n\n  return context;\n}\n\nexport function StoreScopeProvider<T>({ scope, store: inputStore, children }: StoreScopeProps<T>) {\n  const context = getStoreScopeContext(scope);\n  const currentStore = useMemo(() => inputStore ?? store(scope.defaultValue), [scope, inputStore]);\n\n  return <context.Provider value={currentStore}>{children}</context.Provider>;\n}\n\nexport function useStoreScope<T>(scope: StoreScope<T>): Store<T> {\n  const context = getStoreScopeContext(scope);\n  return useContext(context);\n}\n","/**\n * @license React\n * use-sync-external-store-with-selector.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var g=require(\"react\");function n(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var p=\"function\"===typeof Object.is?Object.is:n,q=g.useSyncExternalStore,r=g.useRef,t=g.useEffect,u=g.useMemo,v=g.useDebugValue;\nexports.useSyncExternalStoreWithSelector=function(a,b,e,l,h){var c=r(null);if(null===c.current){var f={hasValue:!1,value:null};c.current=f}else f=c.current;c=u(function(){function a(a){if(!c){c=!0;d=a;a=l(a);if(void 0!==h&&f.hasValue){var b=f.value;if(h(b,a))return k=b}return k=a}b=k;if(p(d,a))return b;var e=l(a);if(void 0!==h&&h(b,e))return b;d=a;return k=e}var c=!1,d,k,m=void 0===e?null:e;return[function(){return a(b())},null===m?void 0:function(){return a(m())}]},[b,e,l,h]);var d=q(a,c[0],c[1]);\nt(function(){f.hasValue=!0;f.value=d},[d]);v(d);return d};\n","/**\n * @license React\n * use-sync-external-store-with-selector.development.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nif (process.env.NODE_ENV !== \"production\") {\n  (function() {\n\n          'use strict';\n\n/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */\nif (\n  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&\n  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===\n    'function'\n) {\n  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());\n}\n          var React = require('react');\n\n/**\n * inlined Object.is polyfill to avoid requiring consumers ship their own\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n */\nfunction is(x, y) {\n  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare\n  ;\n}\n\nvar objectIs = typeof Object.is === 'function' ? Object.is : is;\n\nvar useSyncExternalStore = React.useSyncExternalStore;\n\n// for CommonJS interop.\n\nvar useRef = React.useRef,\n    useEffect = React.useEffect,\n    useMemo = React.useMemo,\n    useDebugValue = React.useDebugValue; // Same as useSyncExternalStore, but supports selector and isEqual arguments.\n\nfunction useSyncExternalStoreWithSelector(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {\n  // Use this to track the rendered snapshot.\n  var instRef = useRef(null);\n  var inst;\n\n  if (instRef.current === null) {\n    inst = {\n      hasValue: false,\n      value: null\n    };\n    instRef.current = inst;\n  } else {\n    inst = instRef.current;\n  }\n\n  var _useMemo = useMemo(function () {\n    // Track the memoized state using closure variables that are local to this\n    // memoized instance of a getSnapshot function. Intentionally not using a\n    // useRef hook, because that state would be shared across all concurrent\n    // copies of the hook/component.\n    var hasMemo = false;\n    var memoizedSnapshot;\n    var memoizedSelection;\n\n    var memoizedSelector = function (nextSnapshot) {\n      if (!hasMemo) {\n        // The first time the hook is called, there is no memoized result.\n        hasMemo = true;\n        memoizedSnapshot = nextSnapshot;\n\n        var _nextSelection = selector(nextSnapshot);\n\n        if (isEqual !== undefined) {\n          // Even if the selector has changed, the currently rendered selection\n          // may be equal to the new selection. We should attempt to reuse the\n          // current value if possible, to preserve downstream memoizations.\n          if (inst.hasValue) {\n            var currentSelection = inst.value;\n\n            if (isEqual(currentSelection, _nextSelection)) {\n              memoizedSelection = currentSelection;\n              return currentSelection;\n            }\n          }\n        }\n\n        memoizedSelection = _nextSelection;\n        return _nextSelection;\n      } // We may be able to reuse the previous invocation's result.\n\n\n      // We may be able to reuse the previous invocation's result.\n      var prevSnapshot = memoizedSnapshot;\n      var prevSelection = memoizedSelection;\n\n      if (objectIs(prevSnapshot, nextSnapshot)) {\n        // The snapshot is the same as last time. Reuse the previous selection.\n        return prevSelection;\n      } // The snapshot has changed, so we need to compute a new selection.\n\n\n      // The snapshot has changed, so we need to compute a new selection.\n      var nextSelection = selector(nextSnapshot); // If a custom isEqual function is provided, use that to check if the data\n      // has changed. If it hasn't, return the previous selection. That signals\n      // to React that the selections are conceptually equal, and we can bail\n      // out of rendering.\n\n      // If a custom isEqual function is provided, use that to check if the data\n      // has changed. If it hasn't, return the previous selection. That signals\n      // to React that the selections are conceptually equal, and we can bail\n      // out of rendering.\n      if (isEqual !== undefined && isEqual(prevSelection, nextSelection)) {\n        return prevSelection;\n      }\n\n      memoizedSnapshot = nextSnapshot;\n      memoizedSelection = nextSelection;\n      return nextSelection;\n    }; // Assigning this to a constant so that Flow knows it can't change.\n\n\n    // Assigning this to a constant so that Flow knows it can't change.\n    var maybeGetServerSnapshot = getServerSnapshot === undefined ? null : getServerSnapshot;\n\n    var getSnapshotWithSelector = function () {\n      return memoizedSelector(getSnapshot());\n    };\n\n    var getServerSnapshotWithSelector = maybeGetServerSnapshot === null ? undefined : function () {\n      return memoizedSelector(maybeGetServerSnapshot());\n    };\n    return [getSnapshotWithSelector, getServerSnapshotWithSelector];\n  }, [getSnapshot, getServerSnapshot, selector, isEqual]),\n      getSelection = _useMemo[0],\n      getServerSelection = _useMemo[1];\n\n  var value = useSyncExternalStore(subscribe, getSelection, getServerSelection);\n  useEffect(function () {\n    inst.hasValue = true;\n    inst.value = value;\n  }, [value]);\n  useDebugValue(value);\n  return value;\n}\n\nexports.useSyncExternalStoreWithSelector = useSyncExternalStoreWithSelector;\n          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */\nif (\n  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&\n  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===\n    'function'\n) {\n  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());\n}\n        \n  })();\n}\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/use-sync-external-store-with-selector.production.min.js');\n} else {\n  module.exports = require('./cjs/use-sync-external-store-with-selector.development.js');\n}\n","import type { SubscribeOptions } from '@core/commonTypes';\nimport type { Store } from '@core/store';\nimport { hash } from '@lib/hash';\nimport { trackingProxy } from '@lib/trackingProxy';\nimport { useCallback, useDebugValue, useLayoutEffect, useRef } from 'react';\nimport { useSyncExternalStoreWithSelector } from 'use-sync-external-store/with-selector';\n\nexport type UseStoreOptions = Omit<SubscribeOptions, 'runNow'>;\n\nexport function useStore<T>(store: Store<T>, options?: UseStoreOptions): T {\n  const lastEqualsRef = useRef<(newValue: T) => boolean>();\n\n  const subOptions = { ...options, runNow: false, equals: undefined };\n\n  const subscribe = useCallback(\n    (listener: () => void) => {\n      return store.sub(listener, subOptions);\n    },\n    [store, hash(subOptions)]\n  );\n\n  const value = useSyncExternalStoreWithSelector(\n    //\n    subscribe,\n    store.get,\n    undefined,\n    (x) => x,\n    options?.equals ?? ((_v, newValue) => lastEqualsRef.current?.(newValue) ?? false)\n  );\n  const [proxiedValue, equals] = trackingProxy(value);\n\n  useLayoutEffect(() => {\n    lastEqualsRef.current = equals;\n  });\n\n  useDebugValue(value);\n  return proxiedValue;\n}\n","import type { Store } from '@core/store';\nimport type { UpdateFn } from '@core/commonTypes';\nimport type { UseStoreOptions } from './useStore';\nimport { useStore } from './useStore';\n\nexport function useProp<T>(store: Store<T>, options?: UseStoreOptions): [value: T, setValue: UpdateFn<T>] {\n  const value = useStore(store, options);\n\n  return [value, store.update];\n}\n"],"names":["a","c","d","b","e","useRef","useMemo","useDebugValue","require$$0","require$$1","store","useSyncExternalStoreWithSelector"],"mappings":"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"}

package/dist/types/core/commonTypes.d.ts

@@ -0,0 +1,51 @@
+import type { FetchStore } from './fetchStore';
+import type { Store } from './store';
+export interface Listener<T = void> {
+    (value: T, previouseValue?: T): void;
+}
+export interface Selector<T, S> {
+    (value: T): S;
+}
+export interface Effect {
+    (): void | Cancel;
+}
+export interface SubscribeOptions {
+    /** Whether to execute the callback immediately with the current store value.
+     * @default true
+     */
+    runNow?: boolean;
+    /** If set, throttle how often the callback can be executed.
+     * The values says how much time needs to pass between to calls.
+     * @example
+     * subscribe(callback, { throttle: { seconds: 10 } }); // Will execute immediately and then at least 10 seconds havbe to pass. If the store changed during those 10 seconds, the callback will be executed again.
+     */
+    throttle?: Duration;
+    /** Provide a custom equality function. By default a strict equals (===) will be used.
+     */
+    equals?: (a: any, b: any) => boolean;
+    tag?: any;
+}
+export interface Cancel {
+    (): void;
+}
+export type Duration = number | {
+    milliseconds?: number;
+    seconds?: number;
+    minutes?: number;
+    hours?: number;
+    days?: number;
+};
+export type UpdateFrom<Value, From extends any[]> = Value | ((...args: From) => Value);
+export type Update<Value> = UpdateFrom<Value, [Value]>;
+export interface UpdateFn<Value> {
+    (update: Update<Value>): void;
+}
+export interface UseOptions {
+    disableProxy?: boolean;
+}
+export interface Use {
+    <T>(store: Store<T>, options?: UseOptions): T;
+}
+export interface UseFetch {
+    <T>(fetchStore: FetchStore<T>): Promise<T>;
+}

package/dist/types/core/derivedStore.d.ts

@@ -0,0 +1,39 @@
+import { CalculationHelper } from '../lib/calculationHelper';
+import type { Path, Value } from '../lib/propAccess';
+import type { Cancel, Selector, Update, Use } from './commonTypes';
+import { Store } from './store';
+export declare class DerivedStore<T> extends Store<T> {
+    protected calculate: (this: {
+        use: Use;
+    }, fns: {
+        use: Use;
+    }) => T;
+    protected derivedFrom?: {
+        store: Store<any>;
+        selectors: (Selector<any, any> | string)[];
+    } | undefined;
+    calculationHelper: CalculationHelper<T>;
+    protected valid: boolean;
+    protected check?: () => void;
+    protected cancel?: Cancel;
+    constructor(calculate: (this: {
+        use: Use;
+    }, fns: {
+        use: Use;
+    }) => T, derivedFrom?: {
+        store: Store<any>;
+        selectors: (Selector<any, any> | string)[];
+    } | undefined);
+    get(): T;
+    update(update: Update<T>): void;
+    map<S>(selector: Selector<T, S>): DerivedStore<S>;
+    map<P extends Path<T>>(selector: P): DerivedStore<Value<T, P>>;
+    protected invalidate(): void;
+}
+declare function _derivedStore<T>(calculate: (this: {
+    use: Use;
+}, fns: {
+    use: Use;
+}) => T): DerivedStore<T>;
+export declare const derivedStore: typeof _derivedStore;
+export {};

package/dist/types/core/fetchStore.d.ts

@@ -0,0 +1,76 @@
+import { CalculationHelper } from '../lib/calculationHelper';
+import type { Path, Value } from '../lib/propAccess';
+import type { Cancel, Duration, Listener, Selector, SubscribeOptions, Update, Use, UseFetch } from './commonTypes';
+import type { ResourceGroup } from './resourceGroup';
+import { Store } from './store';
+type Common<T> = {
+    isUpdating: false;
+    update?: undefined;
+    ref: unknown;
+} | {
+    isUpdating: true;
+    update: Promise<T>;
+    ref: unknown;
+};
+type WithValue<T> = {
+    status: 'value';
+    value: T;
+    error?: undefined;
+    isStale: boolean;
+} & Common<T>;
+type WithError<T> = {
+    status: 'error';
+    value?: undefined;
+    error: unknown;
+    isStale: boolean;
+} & Common<T>;
+type Pending<T> = {
+    status: 'pending';
+    value?: undefined;
+    error?: undefined;
+    isStale: true;
+} & Common<T>;
+export type FetchStoreState<T> = WithValue<T> | WithError<T> | Pending<T>;
+export interface FetchOptions {
+    cache?: 'updateWhenStale' | 'backgroundUpdate' | 'forceUpdate';
+}
+export interface FetchFn<T, Args extends any[] = []> {
+    (this: {
+        use: Use;
+        useFetch: UseFetch;
+    }, ...args: Args): Promise<T>;
+}
+export interface FetchStoreOptions<T> {
+    invalidateAfter?: Duration | ((state: FetchStoreState<T>) => Duration);
+    clearAfter?: Duration | ((state: FetchStoreState<T>) => Duration);
+    resourceGroup?: ResourceGroup | ResourceGroup[];
+    retain?: number;
+    clearUnusedAfter?: Duration;
+}
+export declare class FetchStore<T> extends Store<FetchStoreState<T>> {
+    protected fetchFn: FetchFn<T>;
+    protected options: FetchStoreOptions<T>;
+    calculationHelper: CalculationHelper<T>;
+    constructor(fetchFn: FetchFn<T>, options?: FetchStoreOptions<T>);
+    update(value: Update<FetchStoreState<T>>): void;
+    fetch(options?: FetchOptions): Promise<T>;
+    setValue(value: T | Promise<T>): void;
+    protected setPromise(promise: Promise<T>): void;
+    setError(error: unknown): void;
+    invalidate(): void;
+    clear(): void;
+    sub(listener: Listener<FetchStoreState<T>>, options?: SubscribeOptions): Cancel;
+    mapValue<S>(selector: Selector<T, S>): FetchStore<S>;
+    mapValue<P extends Path<T>>(selector: P): FetchStore<Value<T, P>>;
+}
+declare function create<T>(fetch: FetchFn<T>, options?: FetchStoreOptions<T>): FetchStore<T>;
+declare function withArgs<T, Args extends any[]>(fetch: FetchFn<T, Args>, options?: FetchStoreOptions<T>): {
+    (...args: Args): FetchStore<T>;
+    invalidate: () => void;
+    clear: () => void;
+};
+export declare const fetchStore: typeof create & {
+    withArgs: typeof withArgs;
+    defaultOptions: FetchStoreOptions<unknown>;
+};
+export {};

package/dist/types/core/index.d.ts

@@ -0,0 +1,10 @@
+export type { Cancel, Duration, Effect, Listener, SubscribeOptions } from './commonTypes';
+export { derivedStore } from './derivedStore';
+export type { DerivedStore } from './derivedStore';
+export { fetchStore } from './fetchStore';
+export type { FetchFn, FetchOptions, FetchStore, FetchStoreOptions, FetchStoreState } from './fetchStore';
+export { once } from './once';
+export { allResources, ResourceGroup } from './resourceGroup';
+export type { Resource } from './resourceGroup';
+export { store } from './store';
+export type { BoundStoreActions, Store, StoreActions, StoreOptions, StoreOptionsWithActions } from './store';

package/dist/types/core/once.d.ts

@@ -0,0 +1,13 @@
+import type { Cancel, Listener } from './commonTypes';
+interface Subscribe<T> {
+    (listener: Listener<T>, options?: {
+        runNow?: boolean;
+    }): Cancel;
+}
+export declare function once<T, S extends T>(subscribe: Subscribe<T>, condition: (value: T) => value is S): Promise<S>;
+export declare function once<T>(subscribe: Subscribe<T>, condition?: (value: T) => boolean): Promise<T>;
+export declare function onceValue<T>(subscribe: Subscribe<{
+    value?: T;
+    error?: unknown;
+}>): Promise<T>;
+export {};

package/dist/types/core/resourceGroup.d.ts

@@ -0,0 +1,9 @@
+export interface Resource {
+    invalidate(): void;
+    clear(): void;
+}
+export declare class ResourceGroup extends Set<Resource> {
+    invalidate(): void;
+    clear(): void;
+}
+export declare const allResources: ResourceGroup;

package/dist/types/core/store.d.ts

@@ -0,0 +1,58 @@
+import type { Path, Value } from '../lib/propAccess';
+import { arrayActions, mapActions, recordActions, setActions } from '../lib/storeActions';
+import type { Cancel, Duration, Effect, Listener, Selector, SubscribeOptions, Update, Use, UseOptions } from './commonTypes';
+import { DerivedStore } from './derivedStore';
+export type StoreActions = Record<string, (...args: any[]) => any>;
+export type BoundStoreActions<T, Actions extends StoreActions> = Actions & ThisType<Store<T> & Actions>;
+export interface StoreOptions {
+    retain?: number;
+}
+export interface StoreOptionsWithActions<T, Actions extends StoreActions> extends StoreOptions {
+    methods?: Actions & ThisType<Store<T> & Actions & StandardActions<T>>;
+}
+type StandardActions<T> = T extends Map<any, any> ? typeof mapActions : T extends Set<any> ? typeof setActions : T extends Array<any> ? typeof arrayActions : T extends Record<any, any> ? typeof recordActions : Record<string, never>;
+type StoreWithActions<T, Actions extends StoreActions> = Store<T> & Omit<BoundStoreActions<T, Actions>, keyof Store<T>> & StandardActions<T>;
+export declare class Store<T> {
+    protected readonly initialValue: T;
+    protected readonly options: StoreOptions;
+    protected value: T;
+    protected listeners: Set<Listener<void>>;
+    protected effects: Map<Effect, {
+        handle?: Cancel | undefined;
+        retain?: number | undefined;
+        timeout?: number | undefined;
+    }>;
+    protected notifyId: {};
+    constructor(initialValue: T, options?: StoreOptions);
+    get(): T;
+    update(update: Update<T>): void;
+    sub(listener: Listener<T>, options?: SubscribeOptions): Cancel;
+    map<S>(selector: Selector<T, S>, options?: UseOptions): DerivedStore<S>;
+    map<P extends Path<T>>(selector: P, options?: UseOptions): DerivedStore<Value<T, P>>;
+    /** Add an effect that will be executed when the store becomes active, which means when it has at least one subscriber.
+     * @param effect
+     * If there is already a subscriber, the effect will be executed immediately.
+     * Otherweise it will be executed as soon as the first subscription is created.
+     * Every time all subscriptions are removed and the first is created again, the effect will be executed again.
+     * @param retain
+     * If provided, delay tearing down effects when the last subscriber is removed. This is useful if a short gap in subscriber coverage is supposed to be ignored. E.g. when switching pages, the old page might unsubscribe, while the new page subscribes immediately after.
+     * @returns
+     * The effect can return a teardown callback, which will be executed when the last subscription is removed and potentially the ratain time has passed.
+     */
+    addEffect(effect: Effect, retain?: Duration): () => void;
+    /** Return whether the store is currently active, which means whether it has at least one subscriber. */
+    get isActive(): boolean;
+    protected onSubscribe(): void;
+    protected onUnsubscribe(): void;
+    protected notify(): void;
+}
+declare function _store<T>(calculate: (this: {
+    use: Use;
+}, fns: {
+    use: Use;
+}) => T, options?: StoreOptions): DerivedStore<T>;
+declare function _store<T, Actions extends StoreActions = {}>(initialState: T, options?: StoreOptionsWithActions<T, Actions>): StoreWithActions<T, Actions>;
+export declare const store: typeof _store & {
+    defaultOptions: StoreOptions;
+};
+export {};

package/dist/types/core/storeScope.d.ts

@@ -0,0 +1,4 @@
+export declare class StoreScope<T> {
+    readonly defaultValue: T;
+    constructor(defaultValue: T);
+}

package/dist/types/immer/immerActions.d.ts

@@ -0,0 +1,5 @@
+import type { Store } from '../core/store';
+import type { Draft, nothing } from '../immer';
+export declare const immerActions: {
+    immerUpdate<T>(this: Store<T>, recipe: (draft: Draft<T>) => void | Draft<T> | (Draft<T> extends undefined ? import("immer/dist/internal").Nothing : never) | undefined): void;
+};

package/dist/types/immer/index.d.ts

@@ -0,0 +1 @@
+export { immerActions } from './immerActions';

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './core';
+export { Cache } from './lib/cache';
+export { calcDuration } from './lib/calcDuration';
+export { arrayActions, mapActions, recordActions, setActions } from './lib/storeActions';

package/dist/types/lib/bind.d.ts

@@ -0,0 +1 @@
+export declare function bind(self: any): void;

package/dist/types/lib/cache.d.ts

@@ -0,0 +1,17 @@
+export declare class Cache<Args extends any[], T extends object> {
+    private factory;
+    private cacheTime?;
+    private cache;
+    private interval;
+    constructor(factory: (...args: Args) => T, cacheTime?: number | undefined);
+    cleanup(): void;
+    get(...args: Args): T;
+    values(): T[];
+    stop(): void;
+    stats(): {
+        count: number;
+        withRef: number;
+        withWeakRef: number;
+    };
+    private now;
+}

package/dist/types/lib/calcDuration.d.ts

@@ -0,0 +1,2 @@
+import type { Duration } from '../core/commonTypes';
+export declare const calcDuration: (t: Duration) => number;

package/dist/types/lib/calculationHelper.d.ts

@@ -0,0 +1,22 @@
+import type { Cancel, UpdateFrom, Use, UseFetch } from '../core/commonTypes';
+import type { MaybePromise } from './maybePromise';
+export declare class CalculationHelper<T> {
+    private options;
+    private current?;
+    constructor(options: {
+        calculate: (fns: {
+            use: Use;
+            useFetch: UseFetch;
+            updateValue: (update: UpdateFrom<MaybePromise<T>, [T | undefined]>) => void;
+            updateError: (error: unknown) => void;
+        }) => Cancel | void;
+        addEffect: (effect: () => Cancel | void) => Cancel;
+        getValue: () => T | undefined;
+        setValue?: (value: T) => void;
+        setError?: (error: unknown) => void;
+        onInvalidate?: () => void;
+    });
+    execute(): void;
+    stop(): void;
+    check(): void;
+}

package/dist/types/lib/diff.d.ts

@@ -0,0 +1,7 @@
+export interface Patch {
+    op: 'replace' | 'remove' | 'add';
+    path: (string | number)[];
+    value?: any;
+    prevValue?: any;
+}
+export declare function diff(a: any, b: any, prefix?: (string | number)[]): Iterable<Patch>;

package/dist/types/lib/equals.d.ts

@@ -0,0 +1,3 @@
+export declare const defaultEquals: (a: any, b: any) => boolean;
+export declare const simpleShallowEquals: (a: any, b: any) => boolean;
+export declare const simpleDeepEquals: (a: any, b: any) => boolean;

package/dist/types/lib/forwardError.d.ts

@@ -0,0 +1 @@
+export declare function forwardError(error: unknown): void;

package/dist/types/lib/hash.d.ts

@@ -0,0 +1 @@
+export declare function hash(value: unknown): string;

package/dist/types/lib/makeSelector.d.ts

@@ -0,0 +1 @@
+export declare function makeSelector<T, S>(selector?: ((value: T) => S) | string): (value: T) => S;

package/dist/types/lib/maybePromise.d.ts

@@ -0,0 +1 @@
+export type MaybePromise<T> = T | Promise<T>;

package/dist/types/lib/propAccess.d.ts

@@ -0,0 +1,13 @@
+import type { Update } from '../core/commonTypes';
+type FilterKey<T> = T extends string | number ? T : never;
+type FilterString<T> = T extends string ? T : never;
+export type Obj = Record<string | number, unknown>;
+export type Arr = readonly unknown[];
+type GetKeys<T> = T extends Arr ? T extends readonly [] ? never : '0' extends keyof T ? keyof T & `${number}` : number : keyof T;
+export type Path<T> = 0 extends 1 & T ? string : T extends never ? never : T extends Obj | Arr ? FilterString<keyof {
+    [K in FilterKey<GetKeys<T>> as `${K}` | (T[K] extends Obj | Arr | undefined | null ? `${K}.${Path<NonNullable<T[K]>>}` : never)]: 0;
+}> : never;
+export type Value<T, P extends string> = P extends `${infer K}.${infer Rest}` ? T[K & keyof T] extends Obj | Arr ? Value<T[K & keyof T], Rest> : T[K & keyof T] extends Obj | Arr | undefined | null ? Value<NonNullable<T[K & keyof T]>, Rest> | undefined : never : T[P & keyof T];
+export declare function get<T, P extends Path<T>>(obj: T, path: P): Value<T, P>;
+export declare function set<T, P extends Path<T>>(obj: T, path: P, value: Update<Value<T, P>>, rootPath?: P): T;
+export {};

package/dist/types/lib/queue.d.ts

@@ -0,0 +1,9 @@
+import type { MaybePromise } from './maybePromise';
+type Action<T> = () => MaybePromise<T>;
+export interface Queue {
+    <T>(action: Action<T>): Promise<T>;
+    clear: () => void;
+    whenDone: Promise<void>;
+}
+export declare function queue(): Queue;
+export {};

package/dist/types/lib/storeActions.d.ts

@@ -0,0 +1,26 @@
+import type { Update } from '../core/commonTypes';
+import type { Store } from '../core/store';
+export declare const arrayActions: {
+    splice: <V>(this: Store<V[]>, start: number, deleteCount: number, ...items: V[]) => V[];
+    push: <V_1>(this: Store<V_1[]>, ...args: V_1[]) => number;
+    pop: <V_2>(this: Store<V_2[]>) => V_2 | undefined;
+    shift: <V_3>(this: Store<V_3[]>) => V_3 | undefined;
+    unshift: <V_4>(this: Store<V_4[]>, ...args: V_4[]) => number;
+    reverse: <V_5>(this: Store<V_5[]>) => V_5[];
+    sort: <V_6>(this: Store<V_6[]>, compareFn?: ((a: V_6, b: V_6) => number) | undefined) => V_6[];
+};
+export declare const recordActions: {
+    set<K extends string | number | symbol, V>(this: Store<Record<K, V>>, key: K, value: Update<V>): Store<Record<K, V>>;
+    delete<K_1 extends string | number | symbol, V_1>(this: Store<Record<K_1, V_1>>, key: K_1): void;
+    clear<K_2 extends string | number | symbol, V_2>(this: Store<Record<K_2, V_2>>): void;
+};
+export declare const mapActions: {
+    set<K, V>(this: Store<Map<K, V>>, key: K, value: V): Store<Map<K, V>>;
+    delete<K_1, V_1>(this: Store<Map<K_1, V_1>>, key: K_1): boolean;
+    clear<K_2, V_2>(this: Store<Map<K_2, V_2>>): void;
+};
+export declare const setActions: {
+    add<T>(this: Store<Set<T>>, value: T): void;
+    delete<T_1>(this: Store<Set<T_1>>, value: T_1): void;
+    clear<T_2>(this: Store<Set<T_2>>): void;
+};

package/dist/types/lib/throttle.d.ts

@@ -0,0 +1 @@
+export declare function throttle<Args extends any[]>(fn: (...args: Args) => void, ms: number): (...args: Args) => void;

package/dist/types/lib/trackingProxy.d.ts

@@ -0,0 +1,2 @@
+export type TrackingProxy<T> = [value: T, equals: (newValue: T) => boolean];
+export declare function trackingProxy<T>(value: T): TrackingProxy<T>;

package/dist/types/lib/unwrapPromise.d.ts

@@ -0,0 +1 @@
+export type UnwrapPromise<T> = T extends Promise<infer S> ? UnwrapPromise<S> : T;

package/dist/types/react/index.d.ts

@@ -0,0 +1,5 @@
+export { StoreScopeProvider, useStoreScope } from './storeScope';
+export type { StoreScopeProps } from './storeScope';
+export { useProp } from './useProp';
+export { useStore } from './useStore';
+export type { UseStoreOptions } from './useStore';

package/dist/types/react/read.d.ts

@@ -0,0 +1,4 @@
+import type { FetchStore } from '../core/fetchStore';
+import type { SubscribeOptions } from '../core/commonTypes';
+export type UseStoreOptions = Omit<SubscribeOptions, 'runNow'>;
+export declare function read<T>(store: FetchStore<T>, options?: UseStoreOptions): T;

package/dist/types/react/storeScope.d.ts

@@ -0,0 +1,12 @@
+import type { Store } from '../core/store';
+import type { StoreScope } from '../core/storeScope';
+import type { Context, ReactNode } from '../react';
+export type StoreScopeProps<T> = {
+    scope: StoreScope<T>;
+    store?: Store<T>;
+    children?: ReactNode;
+};
+export declare const contextMap: WeakMap<StoreScope<any>, Context<Store<any>>>;
+export declare function getStoreScopeContext<T>(scope: StoreScope<T>): Context<Store<T>>;
+export declare function StoreScopeProvider<T>({ scope, store: inputStore, children }: StoreScopeProps<T>): JSX.Element;
+export declare function useStoreScope<T>(scope: StoreScope<T>): Store<T>;

package/dist/types/react/useProp.d.ts

@@ -0,0 +1,4 @@
+import type { Store } from '../core/store';
+import type { UpdateFn } from '../core/commonTypes';
+import type { UseStoreOptions } from './useStore';
+export declare function useProp<T>(store: Store<T>, options?: UseStoreOptions): [value: T, setValue: UpdateFn<T>];

package/dist/types/react/useStore.d.ts

@@ -0,0 +1,4 @@
+import type { SubscribeOptions } from '../core/commonTypes';
+import type { Store } from '../core/store';
+export type UseStoreOptions = Omit<SubscribeOptions, 'runNow'>;
+export declare function useStore<T>(store: Store<T>, options?: UseStoreOptions): T;

package/package.json

@@ -0,0 +1,112 @@
+{
+  "name": "cross-state",
+  "type": "module",
+  "repository": "schummar/schummar-state",
+  "version": "0.6.0",
+  "description": "(React) state library",
+  "sideEffects": false,
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/es/index.mjs",
+  "exports": {
+    ".": {
+      "import": "./dist/es/index.mjs",
+      "require": "./dist/cjs/index.cjs",
+      "default": "./dist/es/index.mjs"
+    },
+    "./react": {
+      "import": "./dist/es/react.mjs",
+      "require": "./dist/cjs/react.cjs",
+      "default": "./dist/es/react.mjs"
+    },
+    "./immer": {
+      "import": "./dist/es/immer.mjs",
+      "require": "./dist/cjs/immer.cjs",
+      "default": "./dist/es/immer.mjs"
+    }
+  },
+  "types": "dist/types/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "dist/types/index.d.ts"
+      ],
+      "react": [
+        "dist/types/react/index.d.ts"
+      ],
+      "immer": [
+        "dist/types/immer/index.d.ts"
+      ]
+    }
+  },
+  "author": {
+    "name": "Marco Schumacher",
+    "email": "marco@schumacher.dev"
+  },
+  "license": "ISC",
+  "scripts": {
+    "start": "tsc --watch",
+    "build": "runp -k build:clean :p build:compile:*",
+    "build:clean": "rimraf dist",
+    "build:compile:js": "vite build",
+    "build:compile:types": "tsc && tsc-alias",
+    "lint": "runp lint:*",
+    "lint:eslint": "eslint src",
+    "lint:tsc": "tsc --noEmit --emitDeclarationOnly false",
+    "lint:tsc:tests": "tsc --noEmit --emitDeclarationOnly false -p test/tsconfig.json",
+    "prepublishOnly": "runp lint test build",
+    "test": "pnpm test:watch run --coverage",
+    "test:watch": "node --expose-gc node_modules/vitest/vitest.mjs",
+    "test:export": "pnpm test:watch run --coverage --reporter=verbose --reporter=junit --outputFile=test/testResults.xml"
+  },
+  "devDependencies": {
+    "@schummar/runp": "1.8.2",
+    "@testing-library/react": "13.4.0",
+    "@types/react": "18.0.26",
+    "@types/react-dom": "18.0.10",
+    "@types/use-sync-external-store": "0.0.3",
+    "@typescript-eslint/eslint-plugin": "5.48.1",
+    "@typescript-eslint/parser": "5.48.1",
+    "@vitejs/plugin-react": "3.0.1",
+    "@vitest/coverage-c8": "0.27.1",
+    "eslint": "8.32.0",
+    "eslint-plugin-import": "2.27.4",
+    "fast-equals": "4.0.3",
+    "happy-dom": "8.1.4",
+    "immer": "9.0.18",
+    "prettier": "2.8.3",
+    "react": "18.2.0",
+    "react-dom": "18.2.0",
+    "rimraf": "4.0.7",
+    "semantic-release": "20.0.2",
+    "tsc-alias": "^1.8.2",
+    "typescript": "4.9.4",
+    "use-sync-external-store": "1.2.0",
+    "vite": "4.0.4",
+    "vite-tsconfig-paths": "4.0.3",
+    "vitest": "0.27.1"
+  },
+  "peerDependencies": {
+    "@types/react": ">=16.8.0",
+    "immer": ">=9.0.0",
+    "react": ">=16.8.0"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    },
+    "immer": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  },
+  "files": [
+    "dist",
+    "react.js",
+    "react.d.ts"
+  ],
+  "volta": {
+    "node": "18.9.0"
+  }
+}

package/react.d.ts

@@ -0,0 +1 @@
+export * from './dist/types/react';

package/react.js

@@ -0,0 +1 @@
+module.exports = require('./dist/cjs/react.cjs');