muya 2.0.0-beta.2 → 2.0.0

package/{packages/core → src}/debug/development-tools.ts

@@ -1,4 +1,5 @@
-import { isPromise } from '../utils/is'
+import type { GetState, State } from '../types'
+import { isPromise, isState } from '../utils/is'
 
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-expect-error
@@ -19,7 +20,7 @@ interface SendOptions {
   value: unknown
   name: string
 }
-export function sendToDevelopmentTools(options: SendOptions) {
+function sendToDevelopmentTools(options: SendOptions) {
   if (!reduxDevelopmentTools) {
     return
   }
@@ -30,8 +31,22 @@ export function sendToDevelopmentTools(options: SendOptions) {
   reduxDevelopmentTools.send(name, { value, type, message }, type)
 }
 
-export function developmentToolsListener(name: string, type: StateType) {
+function developmentToolsListener(name: string, type: StateType) {
   return (value: unknown) => {
     sendToDevelopmentTools({ name, type, value, message: 'update' })
   }
 }
+
+export function subscribeToDevelopmentTools<T>(state: State<T> | GetState<T>) {
+  if (process.env.NODE_ENV === 'production') {
+    return
+  }
+  let type: StateType = 'state'
+
+  if (!isState(state)) {
+    type = 'derived'
+  }
+  const name = state.stateName?.length ? state.stateName : `${type}(${state.id.toString()})`
+  sendToDevelopmentTools({ name, type, value: state.get(), message: 'initial' })
+  return state.listen(developmentToolsListener(name, type))
+}

package/{packages/core → src}/index.ts

@@ -1,4 +1,5 @@
 export * from './types'
 export { create } from './create'
-export { use } from './use'
+export { select } from './select'
+export { useValue } from './use-value'
 export { shallow } from './utils/shallow'

package/{packages/core/utils/global-scheduler.ts → src/scheduler.ts}

@@ -1,12 +1,18 @@
-import type { SchedulerOptions } from './scheduler'
-import { RESCHEDULE_COUNT, THRESHOLD, THRESHOLD_ITEMS } from './scheduler'
+export const THRESHOLD = 0.2
+export const THRESHOLD_ITEMS = 10
+export const RESCHEDULE_COUNT = 0
 
 interface GlobalSchedulerItem<T> {
   value: T
   id: number
 }
 
-export function createGlobalScheduler() {
+export interface SchedulerOptions<T> {
+  readonly onResolveItem?: (item: T) => void
+  readonly onFinish: () => void
+}
+
+export function createScheduler() {
   const listeners = new Map<number, SchedulerOptions<unknown>>()
   const batches = new Set<GlobalSchedulerItem<unknown>>()
 

package/src/select.ts

@@ -0,0 +1,69 @@
+import { stateScheduler } from './create'
+import { createState } from './create-state'
+import { subscribeToDevelopmentTools } from './debug/development-tools'
+import type { Cache, GetState, IsEqual } from './types'
+import { canUpdate, handleAsyncUpdate } from './utils/common'
+import { isUndefined } from './utils/is'
+
+type StateDependencies<T extends Array<unknown>> = {
+  [K in keyof T]: GetState<T[K]>
+}
+
+/**
+ * Selecting state from multiple states.
+ * It will create new state in read-only mode (without set).
+ */
+export function select<T = unknown, S extends Array<unknown> = []>(
+  states: StateDependencies<S>,
+  selector: (...values: S) => T,
+  isEqual?: IsEqual<T>,
+): GetState<T> {
+  const cache: Cache<T> = {}
+
+  function computedValue(): T {
+    const values = states.map((state) => state.get()) as S
+    return selector(...values)
+  }
+
+  function getValue(): T {
+    if (isUndefined(cache.current)) {
+      const newValue = computedValue()
+      cache.current = handleAsyncUpdate(cache, state.emitter.emit, newValue)
+    }
+    return cache.current
+  }
+
+  const cleanups: Array<() => void> = []
+  for (const dependencyState of states) {
+    const clean = dependencyState.emitter.subscribe(() => {
+      stateScheduler.schedule(state.id, null)
+    })
+    cleanups.push(clean)
+  }
+
+  const state = createState<T>({
+    destroy() {
+      for (const cleanup of cleanups) {
+        cleanup()
+      }
+      clearScheduler()
+      state.emitter.clear()
+      cache.current = undefined
+    },
+    get: getValue,
+  })
+
+  const clearScheduler = stateScheduler.add(state.id, {
+    onFinish() {
+      const newValue = computedValue()
+      cache.current = handleAsyncUpdate(cache, state.emitter.emit, newValue)
+      if (!canUpdate(cache, isEqual)) {
+        return
+      }
+      state.emitter.emit()
+    },
+  })
+
+  subscribeToDevelopmentTools(state)
+  return state
+}

package/src/types.ts

@@ -0,0 +1,66 @@
+import type { Emitter } from './utils/create-emitter'
+
+export type IsEqual<T = unknown> = (a: T, b: T) => boolean
+export type SetStateCb<T> = (value: T | Awaited<T>) => Awaited<T>
+export type SetValue<T> = SetStateCb<T> | Awaited<T>
+export type DefaultValue<T> = T | (() => T)
+export type Listener<T> = (listener: (value?: T) => void) => () => void
+export interface Cache<T> {
+  current?: T
+  previous?: T
+  abortController?: AbortController
+}
+
+export const EMPTY_SELECTOR = <T, S>(stateValue: T) => stateValue as unknown as S
+
+export interface GetState<T> {
+  <S>(selector?: (stateValue: T) => S): undefined extends S ? T : S
+  /**
+   * Get the cached state value.
+   */
+  get: () => T
+  /**
+   * Get the unique id of the state.
+   */
+  id: number
+  /**
+   * Emitter to listen to changes with snapshots.
+   */
+  emitter: Emitter<T>
+  /**
+   * Listen to changes in the state.
+   */
+  listen: Listener<T>
+  /**
+   * Destroy / cleanup the state.
+   * Clean all listeners and make cache value undefined.
+   */
+  destroy: () => void
+  /**
+   * Set the state name. For debugging purposes.
+   */
+  withName: (name: string) => GetState<T>
+  /**
+   * Name of the state. For debugging purposes.
+   */
+  stateName?: string
+  /**
+   * Select particular slice of the state.
+   * It will create "another" state in read-only mode (without set).
+   */
+  select: <S>(selector: (state: T) => S, isEqual?: IsEqual<S>) => GetState<S>
+}
+
+export interface State<T> extends GetState<T> {
+  /**
+   * Setting new state value.
+   * It can be value or function that returns a value (similar to `setState` in React).
+   * If the state is initialized with async code, set will cancel the previous promise.
+   */
+  set: (value: SetValue<T>) => void
+  /**
+   * Set the state name. For debugging purposes.
+   */
+  withName: (name: string) => State<T>
+  isSet: true
+}

package/src/use-value.ts

@@ -0,0 +1,22 @@
+import { useDebugValue, useSyncExternalStore } from 'react'
+import { EMPTY_SELECTOR, type GetState } from './types'
+import { isError, isPromise } from './utils/is'
+
+export function useValue<T, S>(state: GetState<T>, selector: (stateValue: T) => S = EMPTY_SELECTOR): undefined extends S ? T : S {
+  const { emitter } = state
+  const value = useSyncExternalStore<S>(
+    state.emitter.subscribe,
+    () => selector(emitter.getSnapshot()),
+    () => selector(emitter.getInitialSnapshot ? emitter.getInitialSnapshot() : emitter.getSnapshot()),
+  )
+  useDebugValue(value)
+  if (isPromise(value)) {
+    throw value
+  }
+
+  if (isError(value)) {
+    throw value
+  }
+
+  return value as undefined extends S ? T : S
+}

package/{packages/core → src}/utils/__tests__/is.test.ts

@@ -1,5 +1,5 @@
-import { Abort } from '../common'
-import { isPromise, isFunction, isSetValueFunction, isMap, isSet, isArray, isEqualBase, isAbortError } from '../is'
+import { create } from '../../create'
+import { isPromise, isFunction, isSetValueFunction, isMap, isSet, isArray, isEqualBase, isUndefined, isState } from '../is'
 
 describe('isPromise', () => {
   it('should return true for a Promise', () => {
@@ -64,11 +64,28 @@ describe('isEqualBase', () => {
   })
 })
 
-describe('isAbortError', () => {
-  it('should return true for an AbortError', () => {
-    expect(isAbortError(new DOMException('', Abort.Error))).toBe(true)
+describe('isUndefined', () => {
+  it('should return true for undefined', () => {
+    // eslint-disable-next-line unicorn/no-useless-undefined
+    expect(isUndefined(undefined)).toBe(true)
   })
-  it('should return false for a non-AbortError', () => {
-    expect(isAbortError(new DOMException('', 'Error'))).toBe(false)
+  it('should return false for a non-undefined', () => {
+    expect(isUndefined(123)).toBe(false)
+  })
+})
+
+describe('isState', () => {
+  it('should return true for a State real', () => {
+    const state = create(1)
+    expect(isState(state)).toBe(true)
+  })
+
+  it('should return true for a State with derived', () => {
+    const state = create(1)
+    const derived = state.select((v) => v)
+    expect(isState(derived)).toBe(false)
+  })
+  it('should return false for a non-State', () => {
+    expect(isState(123)).toBe(false)
   })
 })

package/{packages/core → src}/utils/common.ts

@@ -1,5 +1,5 @@
 import type { Cache, IsEqual } from '../types'
-import { isUndefined } from './is'
+import { isAbortError, isEqualBase, isPromise, isUndefined } from './is'
 
 // eslint-disable-next-line no-shadow
 export enum Abort {
@@ -7,14 +7,13 @@ export enum Abort {
 }
 
 export interface CancelablePromise<T> {
-  promise?: Promise<T>
+  promise: Promise<T>
   controller?: AbortController
-  resolveInitialPromise?: (value: T) => void
 }
 /**
  * Cancelable promise function, return promise and controller
  */
-export function cancelablePromise<T>(promise: Promise<T>, previousController?: AbortController): CancelablePromise<T> {
+function cancelablePromise<T>(promise: Promise<T>, previousController?: AbortController): CancelablePromise<T> {
   if (previousController) {
     previousController.abort()
   }
@@ -32,12 +31,10 @@ export function cancelablePromise<T>(promise: Promise<T>, previousController?: A
   return { promise: cancelable, controller }
 }
 
-let id = 0
-export function generateId() {
-  return id++
-}
-
-export function canUpdate<T>(cache: Cache<T>, isEqual: IsEqual<T> = (previous, next) => previous === next): boolean {
+/**
+ * Check if the cache value is different from the previous value.
+ */
+export function canUpdate<T>(cache: Cache<T>, isEqual: IsEqual<T> = isEqualBase): boolean {
   if (!isUndefined(cache.current)) {
     if (!isUndefined(cache.previous) && isEqual(cache.current, cache.previous)) {
       return false
@@ -46,3 +43,31 @@ export function canUpdate<T>(cache: Cache<T>, isEqual: IsEqual<T> = (previous, n
   }
   return true
 }
+
+/**
+ * Handle async updates for `create` and `select`
+ */
+export function handleAsyncUpdate<T>(cache: Cache<T>, emit: () => void, value: T): T {
+  if (!isPromise(value)) {
+    return value
+  }
+  if (cache.abortController) {
+    cache.abortController.abort()
+  }
+
+  const { promise, controller } = cancelablePromise(value, cache.abortController)
+  cache.abortController = controller
+
+  return promise
+    .then((result) => {
+      cache.current = result as T
+      emit()
+    })
+    .catch((error) => {
+      if (isAbortError(error)) {
+        return
+      }
+      cache.current = error as T
+      emit()
+    }) as T
+}

package/{packages/core → src}/utils/is.ts

@@ -1,6 +1,5 @@
+import type { SetStateCb, SetValue, State } from '../types'
 import { Abort } from './common'
-import type { SetStateCb, SetValue } from '../types'
-import type { State } from '../create'
 
 export function isPromise<T>(value: unknown): value is Promise<T> {
   return value instanceof Promise
@@ -35,16 +34,14 @@ export function isAbortError(value: unknown): value is DOMException {
   return value instanceof DOMException && value.name === Abort.Error
 }
 
-export function isAnyOtherError(value: unknown): value is Error {
-  return value instanceof Error && value.name !== Abort.Error
+export function isError(value: unknown): value is Error {
+  return value instanceof Error
 }
 
 export function isUndefined(value: unknown): value is undefined {
   return value === undefined
 }
 
-export function isCreate(value: unknown): value is State<unknown> {
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-expect-error
-  return isFunction(value) && value.set !== undefined
+export function isState<T>(value: unknown): value is State<T> {
+  return isFunction(value) && 'get' in value && 'set' in value && 'isSet' in value && value.isSet === true
 }

package/types/create-state.d.ts

@@ -0,0 +1,12 @@
+import type { GetState, SetValue, State } from './types';
+interface GetStateOptions<T> {
+    readonly get: () => T;
+    readonly set?: (value: SetValue<T>) => void;
+    readonly destroy: () => void;
+}
+type FullState<T> = GetStateOptions<T>['set'] extends undefined ? GetState<T> : State<T>;
+/**
+ * This is just utility function to create state base data
+ */
+export declare function createState<T>(options: GetStateOptions<T>): FullState<T>;
+export {};

package/types/create.d.ts

@@ -1,21 +1,9 @@
-import type { Emitter } from './utils/create-emitter';
-import type { Callable, DefaultValue, IsEqual, Listener, SetValue } from './types';
-export declare const createScheduler: {
-    add<T>(id: number, option: import("./utils/scheduler").SchedulerOptions<T>): () => void;
+import type { DefaultValue, IsEqual, State } from './types';
+export declare const stateScheduler: {
+    add<T>(id: number, option: import("./scheduler").SchedulerOptions<T>): () => void;
     schedule<T>(id: number, value: T): void;
 };
-interface RawState<T> {
-    (): T;
-    id: number;
-    set: (value: SetValue<T>) => void;
-    emitter: Emitter<T>;
-    listen: Listener<T>;
-    destroy: () => void;
-    withName: (name: string) => RawState<T>;
-    stateName?: string;
-}
-export type State<T> = {
-    readonly [K in keyof RawState<T>]: RawState<T>[K];
-} & Callable<T>;
+/**
+ * Create state from a default value.
+ */
 export declare function create<T>(initialValue: DefaultValue<T>, isEqual?: IsEqual<T>): State<T>;
-export {};

package/types/debug/development-tools.d.ts

@@ -1,10 +1,3 @@
+import type { GetState, State } from '../types';
 export type StateType = 'state' | 'derived';
-interface SendOptions {
-    message?: string;
-    type: StateType;
-    value: unknown;
-    name: string;
-}
-export declare function sendToDevelopmentTools(options: SendOptions): void;
-export declare function developmentToolsListener(name: string, type: StateType): (value: unknown) => void;
-export {};
+export declare function subscribeToDevelopmentTools<T>(state: State<T> | GetState<T>): (() => void) | undefined;

package/types/index.d.ts

@@ -1,4 +1,5 @@
 export * from './types';
 export { create } from './create';
-export { use } from './use';
+export { select } from './select';
+export { useValue } from './use-value';
 export { shallow } from './utils/shallow';

package/types/{utils/scheduler.d.ts → scheduler.d.ts}

@@ -5,4 +5,7 @@ export interface SchedulerOptions<T> {
     readonly onResolveItem?: (item: T) => void;
     readonly onFinish: () => void;
 }
-export declare function createScheduler<T>(options: SchedulerOptions<T>): (value: T) => void;
+export declare function createScheduler(): {
+    add<T>(id: number, option: SchedulerOptions<T>): () => void;
+    schedule<T>(id: number, value: T): void;
+};

package/types/select.d.ts

@@ -0,0 +1,10 @@
+import type { GetState, IsEqual } from './types';
+type StateDependencies<T extends Array<unknown>> = {
+    [K in keyof T]: GetState<T[K]>;
+};
+/**
+ * Selecting state from multiple states.
+ * It will create new state in read-only mode (without set).
+ */
+export declare function select<T = unknown, S extends Array<unknown> = []>(states: StateDependencies<S>, selector: (...values: S) => T, isEqual?: IsEqual<T>): GetState<T>;
+export {};

package/types/types.d.ts

@@ -1,12 +1,62 @@
-export type AnyFunction = (...args: any[]) => any;
+import type { Emitter } from './utils/create-emitter';
 export type IsEqual<T = unknown> = (a: T, b: T) => boolean;
-export type SetStateCb<T> = (value: T) => Awaited<T>;
+export type SetStateCb<T> = (value: T | Awaited<T>) => Awaited<T>;
 export type SetValue<T> = SetStateCb<T> | Awaited<T>;
 export type DefaultValue<T> = T | (() => T);
-export type Listener<T> = (listener: (value: T) => void) => () => void;
+export type Listener<T> = (listener: (value?: T) => void) => () => void;
 export interface Cache<T> {
     current?: T;
     previous?: T;
+    abortController?: AbortController;
+}
+export declare const EMPTY_SELECTOR: <T, S>(stateValue: T) => S;
+export interface GetState<T> {
+    <S>(selector?: (stateValue: T) => S): undefined extends S ? T : S;
+    /**
+     * Get the cached state value.
+     */
+    get: () => T;
+    /**
+     * Get the unique id of the state.
+     */
+    id: number;
+    /**
+     * Emitter to listen to changes with snapshots.
+     */
+    emitter: Emitter<T>;
+    /**
+     * Listen to changes in the state.
+     */
+    listen: Listener<T>;
+    /**
+     * Destroy / cleanup the state.
+     * Clean all listeners and make cache value undefined.
+     */
+    destroy: () => void;
+    /**
+     * Set the state name. For debugging purposes.
+     */
+    withName: (name: string) => GetState<T>;
+    /**
+     * Name of the state. For debugging purposes.
+     */
+    stateName?: string;
+    /**
+     * Select particular slice of the state.
+     * It will create "another" state in read-only mode (without set).
+     */
+    select: <S>(selector: (state: T) => S, isEqual?: IsEqual<S>) => GetState<S>;
+}
+export interface State<T> extends GetState<T> {
+    /**
+     * Setting new state value.
+     * It can be value or function that returns a value (similar to `setState` in React).
+     * If the state is initialized with async code, set will cancel the previous promise.
+     */
+    set: (value: SetValue<T>) => void;
+    /**
+     * Set the state name. For debugging purposes.
+     */
+    withName: (name: string) => State<T>;
+    isSet: true;
 }
-export type Callable<T> = () => T;
-export declare const EMPTY_SELECTOR: <T>(stateValue: T) => T;

package/types/use-value.d.ts

@@ -0,0 +1,2 @@
+import { type GetState } from './types';
+export declare function useValue<T, S>(state: GetState<T>, selector?: (stateValue: T) => S): undefined extends S ? T : S;

package/types/utils/common.d.ts

@@ -3,13 +3,14 @@ export declare enum Abort {
     Error = "StateAbortError"
 }
 export interface CancelablePromise<T> {
-    promise?: Promise<T>;
+    promise: Promise<T>;
     controller?: AbortController;
-    resolveInitialPromise?: (value: T) => void;
 }
 /**
- * Cancelable promise function, return promise and controller
+ * Check if the cache value is different from the previous value.
  */
-export declare function cancelablePromise<T>(promise: Promise<T>, previousController?: AbortController): CancelablePromise<T>;
-export declare function generateId(): number;
 export declare function canUpdate<T>(cache: Cache<T>, isEqual?: IsEqual<T>): boolean;
+/**
+ * Handle async updates for `create` and `select`
+ */
+export declare function handleAsyncUpdate<T>(cache: Cache<T>, emit: () => void, value: T): T;

package/types/utils/is.d.ts

@@ -1,5 +1,4 @@
-import type { SetStateCb, SetValue } from '../types';
-import type { State } from '../create';
+import type { SetStateCb, SetValue, State } from '../types';
 export declare function isPromise<T>(value: unknown): value is Promise<T>;
 export declare function isFunction<T extends (...args: unknown[]) => unknown>(value: unknown): value is T;
 export declare function isMap(value: unknown): value is Map<unknown, unknown>;
@@ -8,6 +7,6 @@ export declare function isArray(value: unknown): value is Array<unknown>;
 export declare function isEqualBase<T>(valueA: T, valueB: T): boolean;
 export declare function isSetValueFunction<T>(value: SetValue<T>): value is SetStateCb<T>;
 export declare function isAbortError(value: unknown): value is DOMException;
-export declare function isAnyOtherError(value: unknown): value is Error;
+export declare function isError(value: unknown): value is Error;
 export declare function isUndefined(value: unknown): value is undefined;
-export declare function isCreate(value: unknown): value is State<unknown>;
+export declare function isState<T>(value: unknown): value is State<T>;

package/esm/__tests__/create-async.test.js

@@ -1 +0,0 @@
-import{create as r}from"../create";import{waitFor as c}from"@testing-library/react";import{longPromise as m}from"./test-utils";import{isPromise as u}from"../utils/is";import{subscriber as n}from"../subscriber";describe("create",()=>{it("should subscribe to context and notified it with parameters",async()=>{const t=r(1),i=r(2);function s(){return t()+i()}async function a(p){return t()+i()+s()+p}let o=0;const e=n(()=>a(10));expect(u(e.emitter.getSnapshot())).toBe(!0),e.listen(async()=>{o++}),expect(o).toBe(0),expect(await e()).toBe(16),t.set(2),await c(async()=>{}),expect(await e()).toBe(18),expect(o).toBe(4)}),it("should async subscribe to context and notified it",async()=>{const t=r(1),i=r(Promise.resolve(2));async function s(){return await m(),t()+await i()}async function a(){return t()+await i()+await s()}let o=0;const e=n(a);e.listen(()=>{o++}),e(),expect(t.emitter.getSize()).toBe(1),expect(i.emitter.getSize()).toBe(1),expect(e.emitter.getSize()).toBe(1),t.set(2),await c(async()=>{expect(await e()).toBe(8),expect(o).toBe(5)}),i.set(3),await c(async()=>{expect(await e()).toBe(10),expect(o).toBe(10)}),expect(t.emitter.getSize()).toBe(1),expect(i.emitter.getSize()).toBe(1),expect(e.emitter.getSize()).toBe(1),e.destroy(),expect(t.emitter.getSize()).toBe(0),expect(i.emitter.getSize()).toBe(0),expect(e.emitter.getSize()).toBe(0)})});

package/esm/subscriber.js

@@ -1 +0,0 @@
-import{cancelablePromise as F,canUpdate as v,generateId as h}from"./utils/common";import{createContext as x}from"./utils/create-context";import{createEmitter as S}from"./utils/create-emitter";import"./debug/development-tools";import{createGlobalScheduler as C}from"./utils/global-scheduler";import{isAbortError as E,isEqualBase as R,isPromise as m,isUndefined as w}from"./utils/is";const d=C(),b=x(void 0);function U(p){const r={};let u=!1;const a=[],i={},s=S(()=>u?r.current:(u=!0,n()),()=>(u=!0,n()));async function l(){v(r,R)&&(i.controller&&i.controller.abort(),d.schedule(c,null))}const c=h(),f=d.add(c,{onFinish(){r.current=n(),s.emit()}}),T={addEmitter(e){const t=e.subscribe(l);a.push(t)},id:c,sub:l};function y(e){const t=F(e,i.controller);return i.controller=t.controller,t.promise?.then(o=>{r.current=o,s.emit()}).catch(o=>{E(o)||(r.current=o,s.emit())}),t.promise}const n=function(){const e=b.run(T,p);if(!m(e))return r.current=e,e;const t=b.wrap(()=>y(e))();m(t)&&t.catch(()=>null);const o=t;return r.current=o,o};return n.emitter=s,n.destroy=function(){for(const e of a)e();s.clear(),f()},n.id=c,n.listen=function(e){return s.subscribe(()=>{const t=r.current;if(w(t))throw new Error("The value is undefined");e(t)})},n.abort=function(){i.controller&&i.controller.abort()},n}export{b as context,U as subscriber};

package/esm/use.js

@@ -1 +0,0 @@
-import{useDebugValue as u,useEffect as s,useRef as m}from"react";import{EMPTY_SELECTOR as a}from"./types";import{isAnyOtherError as c,isPromise as T}from"./utils/is";import{useSyncExternalStore as d}from"react";import{subMemo as p}from"./utils/sub-memo";const f=10,E=3;function R(t){const e=m({renders:0,startTime:performance.now()});s(()=>{e.current.renders++,!(performance.now()-e.current.startTime<f)&&(e.current.renders<E||(e.current.startTime=performance.now(),e.current.renders=0,console.warn(`Function ${t.name.length>0?t.name:t} seems to be not memoized, wrap the function to the useCallback or use global defined functions.`)))},[t])}function b(t,e=a){const n=p(t),o=n.call(),i=o.emitter.getInitialSnapshot??o.emitter.getSnapshot;s(()=>n.destroy,[t,n.destroy]);const r=d(o.emitter.subscribe,()=>e(o.emitter.getSnapshot()),()=>e(i()));if(u(r),T(r))throw r;if(c(r))throw n.destroy(),r;return r}export{b as use};

package/esm/utils/__tests__/context.test.js

@@ -1 +0,0 @@
-import{createContext as c}from"../create-context";import{longPromise as r}from"../../__tests__/test-utils";describe("context",()=>{it("should check context",()=>{const e=c({name:"John Doe"}),t=()=>{e.run({name:"Jane Doe"},()=>{expect(e.use()).toEqual({name:"Jane Doe"})})};expect(e.use()).toEqual({name:"John Doe"}),t(),expect(e.use()).toEqual({name:"John Doe"})}),it("should test async context",e=>{const t=c("empty"),o=async()=>new Promise(u=>setTimeout(u,10));t.run("outer",()=>{expect(t.use()).toEqual("outer"),setTimeout(t.wrap(async()=>{try{await o(),expect(t.use()).toEqual("outer"),s()}catch(u){e(u)}}),10),t.run("inner",()=>{expect(t.use()).toEqual("inner"),setTimeout(t.wrap(()=>{try{expect(t.use()).toEqual("inner"),s()}catch(u){e(u)}}),10)}),expect(t.use()).toEqual("outer")});let n=0;function s(){n+=1,n===2&&e()}}),it("should test async nested context",e=>{const t=c(0);t.run(1,()=>{expect(t.use()).toEqual(1),t.run(2,()=>{t.run(3,()=>{expect(t.use()).toEqual(3),setTimeout(t.wrap(()=>{expect(t.use()).toEqual(3)}),10),expect(t.use()).toEqual(3)}),setTimeout(t.wrap(()=>{expect(t.use()).toEqual(2)}),10),expect(t.use()).toEqual(2),t.run(3,()=>{expect(t.use()).toEqual(3),setTimeout(t.wrap(()=>{expect(t.use()).toEqual(3),t.run(4,()=>{expect(t.use()).toEqual(4),setTimeout(t.wrap(()=>{expect(t.use()).toEqual(4),e()}),10),expect(t.use()).toEqual(4)})}),10),expect(t.use()).toEqual(3)}),expect(t.use()).toEqual(2)}),expect(t.use()).toEqual(1)}),expect(t.use()).toEqual(0)}),it("should stress test context with async random code",async()=>{const t=c(0);for(let n=0;n<1e4;n++)t.run(n,()=>{expect(t.use()).toEqual(n)});const o=[];for(let n=0;n<1e4;n++)t.run(n,()=>{expect(t.use()).toEqual(n);const s=new Promise(u=>{setTimeout(t.wrap(()=>{expect(t.use()).toEqual(n),u(n)}),Math.random()*100)});o.push(s)});await Promise.all(o)}),it("should-test-default-value-with-ctx",async()=>{const e=c({counter:1});e.run({counter:10},async()=>{await r(10),expect(e.use()?.counter).toBe(10)}),e.run({counter:12},()=>{expect(e.use()?.counter).toBe(12)})}),it("should test nested context",()=>{const t=c({count:0});function o(){const n=t.use();expect(n?.count).toBe(0),t.run({count:1},()=>{const s=t.use();expect(s?.count).toBe(1),t.run({count:2},()=>{const u=t.use();expect(u?.count).toBe(2)})})}o(),o()}),it("should test nested context with async when promise is returned, but not waited",async()=>{const e=c({count:0});async function t(){await r(10);const n=e.use();expect(n?.count).toBe(1)}async function o(){await t(),e.wrap(t);const n=e.use();expect(n?.count).toBe(1)}e.run({count:1},o)})});

package/esm/utils/__tests__/sub-memo.test.js

@@ -1 +0,0 @@
-import{subMemo as t}from"../sub-memo";describe("memo-fn",()=>{it("should create memo fn",()=>{function e(){return!0}const o=t(e);expect(o.call().emitter).toBeDefined()})});

package/esm/utils/create-context.js

@@ -1 +0,0 @@
-import{isPromise as i}from"./is";const a=Symbol("_");function f(s){const t=[];function o(){if(t.length===0)return s;const e=t.at(-1);return e===a?s:e}function u(e,n){t.push(e);const r=n();return i(r)?(async()=>{try{return await r}finally{t.pop()}})():(t.pop(),r)}function c(e){const n=o();return()=>{t.push(n);const r=e();return i(r)?(async()=>{try{return await r}finally{t.pop()}})():(t.pop(),r)}}return{run:u,use:o,wrap:c}}export{f as createContext};

package/esm/utils/global-scheduler.js

@@ -1 +0,0 @@
-import{RESCHEDULE_COUNT as l,THRESHOLD as f,THRESHOLD_ITEMS as d}from"./scheduler";function m(){const t=new Map,r=new Set;let s=performance.now(),u=!1;function c(){const n=performance.now(),e=n-s,{size:o}=r;if(e<f&&o>0&&o<d){s=n,i();return}u||(u=!0,Promise.resolve().then(()=>{u=!1,s=performance.now(),i()}))}function i(){if(r.size===0)return;const n=new Set;for(const e of r){if(t.has(e.id)){n.add(e.id);const{onResolveItem:o}=t.get(e.id);o&&o(e.value)}r.delete(e)}if(r.size>l){c();return}for(const e of n)t.get(e)?.onFinish()}return{add(n,e){return t.set(n,e),()=>{t.delete(n)}},schedule(n,e){r.add({value:e,id:n}),c()}}}export{m as createGlobalScheduler};

package/esm/utils/scheduler.js

@@ -1 +0,0 @@
-const d=.2,T=10,S=0;function E(f){const n=new Set,{onResolveItem:r,onFinish:a}=f;let o=performance.now(),t=!1;function s(){const e=performance.now(),u=e-o,{size:c}=n;if(u<.2&&c>0&&c<10){o=e,i();return}t||(t=!0,Promise.resolve().then(()=>{t=!1,o=performance.now(),i()}))}function i(){if(n.size!==0){for(const e of n)r&&r(e),n.delete(e);if(n.size>0){s();return}a()}}function l(e){n.add(e),s()}return l}export{S as RESCHEDULE_COUNT,d as THRESHOLD,T as THRESHOLD_ITEMS,E as createScheduler};

package/esm/utils/sub-memo.js

@@ -1 +0,0 @@
-import{subscriber as c}from"../subscriber";const n=new WeakMap;let r=0;function p(){return r}function o(){r++}function b(t){return r=0,{call(){const e=n.get(t);if(e)return e.count++,e.returnType;o();const u={count:1,returnType:c(t)};return n.set(t,u),u.returnType},destroy(){const e=n.get(t);e&&(e.count--,e.count===0&&(e.returnType.destroy(),n.delete(t)))}}}export{p as getDebugCacheCreation,b as subMemo};