muya 1.1.0 → 2.0.0-beta.2

package/packages/core/utils/global-scheduler.ts

@@ -0,0 +1,75 @@
+import type { SchedulerOptions } from './scheduler'
+import { RESCHEDULE_COUNT, THRESHOLD, THRESHOLD_ITEMS } from './scheduler'
+
+interface GlobalSchedulerItem<T> {
+  value: T
+  id: number
+}
+
+export function createGlobalScheduler() {
+  const listeners = new Map<number, SchedulerOptions<unknown>>()
+  const batches = new Set<GlobalSchedulerItem<unknown>>()
+
+  let frame = performance.now()
+  let scheduled = false
+
+  function schedule() {
+    const startFrame = performance.now()
+    const frameSizeDiffIn = startFrame - frame
+    const { size } = batches
+    if (frameSizeDiffIn < THRESHOLD && size > 0 && size < THRESHOLD_ITEMS) {
+      frame = startFrame
+      flush()
+      return
+    }
+
+    if (!scheduled) {
+      scheduled = true
+      Promise.resolve().then(() => {
+        scheduled = false
+        frame = performance.now()
+        flush()
+      })
+    }
+  }
+
+  function flush() {
+    if (batches.size === 0) {
+      return
+    }
+
+    const effectedListeners = new Set<number>()
+    for (const value of batches) {
+      if (listeners.has(value.id)) {
+        effectedListeners.add(value.id)
+        const { onResolveItem } = listeners.get(value.id)!
+        if (onResolveItem) {
+          onResolveItem(value.value)
+        }
+      }
+      batches.delete(value)
+    }
+
+    if (batches.size > RESCHEDULE_COUNT) {
+      schedule()
+      return
+    }
+
+    for (const id of effectedListeners) {
+      listeners.get(id)?.onFinish()
+    }
+  }
+
+  return {
+    add<T>(id: number, option: SchedulerOptions<T>) {
+      listeners.set(id, option as SchedulerOptions<unknown>)
+      return () => {
+        listeners.delete(id)
+      }
+    },
+    schedule<T>(id: number, value: T) {
+      batches.add({ value, id })
+      schedule()
+    },
+  }
+}

package/packages/core/utils/is.ts

@@ -0,0 +1,50 @@
+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
+}
+
+export function isFunction<T extends (...args: unknown[]) => unknown>(value: unknown): value is T {
+  return typeof value === 'function'
+}
+
+export function isMap(value: unknown): value is Map<unknown, unknown> {
+  return value instanceof Map
+}
+
+export function isSet(value: unknown): value is Set<unknown> {
+  return value instanceof Set
+}
+
+export function isArray(value: unknown): value is Array<unknown> {
+  return Array.isArray(value)
+}
+
+export function isEqualBase<T>(valueA: T, valueB: T): boolean {
+  if (valueA === valueB) {
+    return true
+  }
+  return !!Object.is(valueA, valueB)
+}
+export function isSetValueFunction<T>(value: SetValue<T>): value is SetStateCb<T> {
+  return typeof value === 'function'
+}
+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 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
+}

package/packages/core/utils/scheduler.ts

@@ -0,0 +1,59 @@
+export const THRESHOLD = 0.2
+export const THRESHOLD_ITEMS = 10
+export const RESCHEDULE_COUNT = 0
+
+export interface SchedulerOptions<T> {
+  readonly onResolveItem?: (item: T) => void
+  readonly onFinish: () => void
+}
+
+export function createScheduler<T>(options: SchedulerOptions<T>) {
+  const batches = new Set<T>()
+  const { onResolveItem, onFinish } = options
+  let frame = performance.now()
+  let scheduled = false
+
+  function schedule() {
+    const startFrame = performance.now()
+    const frameSizeDiffIn = startFrame - frame
+    const { size } = batches
+    if (frameSizeDiffIn < THRESHOLD && size > 0 && size < THRESHOLD_ITEMS) {
+      frame = startFrame
+      flush()
+      return
+    }
+
+    if (!scheduled) {
+      scheduled = true
+      Promise.resolve().then(() => {
+        scheduled = false
+        frame = performance.now()
+        flush()
+      })
+    }
+  }
+
+  function flush() {
+    if (batches.size === 0) {
+      return
+    }
+    for (const value of batches) {
+      if (onResolveItem) {
+        onResolveItem(value)
+      }
+      batches.delete(value)
+    }
+
+    if (batches.size > RESCHEDULE_COUNT) {
+      schedule()
+      return
+    }
+    onFinish()
+  }
+
+  function addValue(value: T) {
+    batches.add(value)
+    schedule()
+  }
+  return addValue
+}

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

@@ -1,13 +1,10 @@
+/* eslint-disable sonarjs/cognitive-complexity */
 import { isArray, isMap, isSet } from './is'
 
-// eslint-disable-next-line sonarjs/cognitive-complexity
 export function shallow<T>(valueA: T, valueB: T): boolean {
   if (valueA == valueB) {
     return true
   }
-  if (Object.is(valueA, valueB)) {
-    return true
-  }
 
   if (typeof valueA !== 'object' || valueA == null || typeof valueB !== 'object' || valueB == null) {
     return false
@@ -43,8 +40,8 @@ export function shallow<T>(valueA: T, valueB: T): boolean {
     return true
   }
 
-  const keysA = Object.keys(valueA as Record<string, unknown>)
-  const keysB = Object.keys(valueB as Record<string, unknown>)
+  const keysA = Object.keys(valueA)
+  const keysB = Object.keys(valueB)
   if (keysA.length !== keysB.length) return false
   for (const key of keysA) {
     if (

package/packages/core/utils/sub-memo.ts

@@ -0,0 +1,49 @@
+import type { Subscribe } from '../subscriber'
+import { subscriber } from '../subscriber'
+import type { AnyFunction } from '../types'
+
+interface CacheItem<T extends AnyFunction> {
+  count: number
+  returnType: Subscribe<T>
+}
+
+const cache = new WeakMap<AnyFunction, CacheItem<AnyFunction>>()
+let cacheCount = 0
+
+export function getDebugCacheCreation() {
+  return cacheCount
+}
+function incrementDebugFunctionCreationCount() {
+  cacheCount++
+}
+
+export function subMemo<F extends AnyFunction>(anyFunction: F) {
+  cacheCount = 0
+  return {
+    call(): Subscribe<F> {
+      const item = cache.get(anyFunction)
+      if (item) {
+        item.count++
+
+        return item.returnType
+      }
+
+      incrementDebugFunctionCreationCount()
+      const returnType = subscriber(anyFunction)
+      const newItem = { count: 1, returnType }
+      cache.set(anyFunction, newItem)
+      return newItem.returnType
+    },
+    destroy() {
+      const item = cache.get(anyFunction)
+
+      if (item) {
+        item.count--
+        if (item.count === 0) {
+          item.returnType.destroy()
+          cache.delete(anyFunction)
+        }
+      }
+    },
+  }
+}

package/types/__tests__/test-utils.d.ts

@@ -0,0 +1,20 @@
+import { Component } from 'react';
+export declare function longPromise(time?: number): Promise<number>;
+export declare class ErrorBoundary extends Component<{
+    fallback: React.ReactNode;
+    children: React.ReactNode;
+}, {
+    hasError: boolean;
+    error: Error | null;
+}> {
+    constructor(props: {
+        fallback: React.ReactNode;
+        children: React.ReactNode;
+    });
+    static getDerivedStateFromError(error: Error): {
+        hasError: boolean;
+        error: Error;
+    };
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    render(): import("react").ReactNode;
+}

package/types/create.d.ts

@@ -1,21 +1,21 @@
-import type { SetterState, DefaultValue, IsEqual } from './types';
-/**
- * Creates a basic atom state.
- * @param defaultValue - The initial state value.
- * @param options - Optional settings for the state (e.g., isEqual, onSet).
- * @returns A state object that can be used as a hook and provides state management methods.
- * @example
- * ```typescript
- * // Global scope
- * const counterState = state(0);
- * const userState = state({ name: 'John', age: 20 });
- *
- * // React component
- * const counter = counterState(); // Use as a hook
- * const user = userState();
- *
- * // Access partial data from the state using slice
- * const userAge = userState.slice((state) => state.age)();
- * ```
- */
-export declare function create<T>(defaultValue: DefaultValue<T>, isEqual?: IsEqual<T>): SetterState<Awaited<T>>;
+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;
+    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>;
+export declare function create<T>(initialValue: DefaultValue<T>, isEqual?: IsEqual<T>): State<T>;
+export {};

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

@@ -0,0 +1,10 @@
+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 {};

package/types/index.d.ts

@@ -1,6 +1,4 @@
 export * from './types';
 export { create } from './create';
-export { select } from './select';
-export { merge } from './merge';
-export { useStateValue } from './use-state-value';
-export { shallow } from './shallow';
+export { use } from './use';
+export { shallow } from './utils/shallow';

package/types/subscriber.d.ts

@@ -0,0 +1,25 @@
+import type { AnyFunction, Callable, Listener } from './types';
+import type { Emitter } from './utils/create-emitter';
+interface SubscribeContext<T = unknown> {
+    addEmitter: (emitter: Emitter<T>) => void;
+    id: number;
+    sub: () => void;
+}
+interface SubscribeRaw<F extends AnyFunction, T extends ReturnType<F> = ReturnType<F>> {
+    (): T;
+    emitter: Emitter<T | undefined>;
+    destroy: () => void;
+    id: number;
+    listen: Listener<T>;
+    abort: () => void;
+}
+export type Subscribe<F extends AnyFunction, T extends ReturnType<F> = ReturnType<F>> = {
+    readonly [K in keyof SubscribeRaw<F, T>]: SubscribeRaw<F, T>[K];
+} & Callable<T>;
+export declare const context: {
+    run: <R>(ctxValue: SubscribeContext<unknown> | undefined, cb: () => R | Promise<R>) => R;
+    use: () => SubscribeContext<unknown> | undefined;
+    wrap: <X>(cb: () => X | Promise<X>) => () => X | Promise<X>;
+};
+export declare function subscriber<F extends AnyFunction, T extends ReturnType<F> = ReturnType<F>>(anyFunction: () => T): Subscribe<F, T>;
+export {};

package/types/types.d.ts

@@ -1,68 +1,12 @@
-import type { Emitter } from './create-emitter';
-/**
- * Equality check function.
- */
+export type AnyFunction = (...args: any[]) => any;
 export type IsEqual<T = unknown> = (a: T, b: T) => boolean;
-export type Setter<T> = (value: T) => T;
-/**
- * Set new state value function.
- */
-export type SetValue<T> = T | Setter<T>;
-export type UpdateValue<T> = T extends object ? Partial<T> : T;
-/**
- * Set new state function
- */
-export type StateValue<T, S> = undefined extends S ? T : S;
-export type Set<T> = (value: SetValue<T>) => void;
-export type Update<T> = (value: UpdateValue<T>) => void;
-/**
- * Getting state value function.
- */
-export type GetState<T> = () => T;
-export interface StateDataInternal<T = unknown> {
-    value?: T;
-    updateVersion: number;
-}
-export declare enum StateKeys {
-    IS_STATE = "isState",
-    IS_SLICE = "isSlice"
-}
-export interface BaseState<T> {
-    /**
-     * Reset state to default value if it's basic atom - if it's family - it will clear all family members
-     */
-    reset: () => void;
-    /**
-     * Get current state value
-     */
-    getState: GetState<T>;
-    select: <S>(selector: (value: T) => S, isEqual?: IsEqual<S>) => GetterState<S>;
-    merge: <T2, S>(state2: GetterState<T2>, selector: (value1: T, value2: T2) => S, isEqual?: IsEqual<S>) => GetterState<S>;
-    /**
-     * Internal state data
-     */
-    __internal: {
-        emitter: Emitter<T>;
-    };
-    subscribe: (listener: (value: T) => void) => () => void;
-}
-export interface GetterState<T> extends BaseState<T> {
-    <S>(selector?: (state: T) => S, isEqual?: IsEqual<S>): StateValue<T, S>;
-}
-export interface SetterState<T> extends GetterState<T> {
-    /**
-     * Set new state value
-     */
-    setState: Set<T>;
-    /**
-     * Set new state value
-     */
-    updateState: Update<T>;
-}
-export type State<T> = SetterState<T> | GetterState<T>;
+export type SetStateCb<T> = (value: T) => Awaited<T>;
+export type SetValue<T> = SetStateCb<T> | Awaited<T>;
 export type DefaultValue<T> = T | (() => T);
-export declare function getDefaultValue<T>(initValue: DefaultValue<T>): T;
-export interface Ref<T> {
-    current: T | undefined;
-    readonly isRef: true;
+export type Listener<T> = (listener: (value: T) => void) => () => void;
+export interface Cache<T> {
+    current?: T;
+    previous?: T;
 }
+export type Callable<T> = () => T;
+export declare const EMPTY_SELECTOR: <T>(stateValue: T) => T;

package/types/use.d.ts

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

package/types/utils/common.d.ts

@@ -0,0 +1,15 @@
+import type { Cache, IsEqual } from '../types';
+export declare enum Abort {
+    Error = "StateAbortError"
+}
+export interface CancelablePromise<T> {
+    promise?: Promise<T>;
+    controller?: AbortController;
+    resolveInitialPromise?: (value: T) => void;
+}
+/**
+ * Cancelable promise function, return promise and controller
+ */
+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;

package/types/utils/create-context.d.ts

@@ -0,0 +1,5 @@
+export declare function createContext<T>(defaultContextValue: T): {
+    run: <R>(ctxValue: T, cb: () => R | Promise<R>) => R;
+    use: () => T | undefined;
+    wrap: <X>(cb: () => X | Promise<X>) => () => X | Promise<X>;
+};

package/types/utils/create-emitter.d.ts

@@ -0,0 +1,20 @@
+export type EmitterSubscribe<P = undefined> = (listener: (...params: P[]) => void) => () => void;
+export interface Emitter<T, P = undefined> {
+    subscribe: EmitterSubscribe<P>;
+    subscribeToOtherEmitter: (emitter: Emitter<unknown>) => void;
+    getSnapshot: () => T;
+    getInitialSnapshot?: () => T;
+    emit: (...params: P[]) => void;
+    getSize: () => number;
+    clear: () => void;
+    contains: (listener: (...params: P[]) => void) => boolean;
+}
+/**
+ * Generics parameters are:
+ * T: Type of the state
+ * R: Type of the snapshot
+ * P: Type of the parameters
+ * @param getSnapshot
+ * @returns
+ */
+export declare function createEmitter<T, P = undefined>(getSnapshot: () => T, getInitialSnapshot?: () => T): Emitter<T, P>;

package/types/utils/global-scheduler.d.ts

@@ -0,0 +1,5 @@
+import type { SchedulerOptions } from './scheduler';
+export declare function createGlobalScheduler(): {
+    add<T>(id: number, option: SchedulerOptions<T>): () => void;
+    schedule<T>(id: number, value: T): void;
+};

package/types/utils/is.d.ts

@@ -0,0 +1,13 @@
+import type { SetStateCb, SetValue } from '../types';
+import type { State } from '../create';
+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>;
+export declare function isSet(value: unknown): value is Set<unknown>;
+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 isUndefined(value: unknown): value is undefined;
+export declare function isCreate(value: unknown): value is State<unknown>;

package/types/utils/scheduler.d.ts

@@ -0,0 +1,8 @@
+export declare const THRESHOLD = 0.2;
+export declare const THRESHOLD_ITEMS = 10;
+export declare const RESCHEDULE_COUNT = 0;
+export interface SchedulerOptions<T> {
+    readonly onResolveItem?: (item: T) => void;
+    readonly onFinish: () => void;
+}
+export declare function createScheduler<T>(options: SchedulerOptions<T>): (value: T) => void;

package/types/utils/sub-memo.d.ts

@@ -0,0 +1,7 @@
+import type { Subscribe } from '../subscriber';
+import type { AnyFunction } from '../types';
+export declare function getDebugCacheCreation(): number;
+export declare function subMemo<F extends AnyFunction>(anyFunction: F): {
+    call(): Subscribe<F>;
+    destroy(): void;
+};

package/esm/common.js

@@ -1 +0,0 @@
-import{useSyncExternalStoreWithSelector as u}from"use-sync-external-store/shim/with-selector";import{useDebugValue as s}from"react";function S(e){return e}function i(e,t,r){const n=u(e.subscribe,e.getSnapshot,e.getSnapshot,t?o=>t(o):S,r);return s(n),n}export{S as toType,i as useSyncExternalStore};

package/esm/create-base-state.js

@@ -1 +0,0 @@
-import{merge as c}from"./merge";import{select as p}from"./select";function y(n){const{emitter:o,getGetterState:s,reset:i,getState:e}=n;return{getState:e,reset:i,select(t,r){const a=s();return p(a,t,r)},merge(t,r,a){const m=s();return c(m,t,r,a)},__internal:{emitter:o},subscribe(t){return t(e()),o.subscribe(()=>{t(e())})}}}export{y as createBaseState};

package/esm/create-emitter.js

@@ -1 +0,0 @@
-function n(r){const t=new Set;return{subscribe:e=>(t.add(e),()=>{t.delete(e)}),emit:(...e)=>{for(const i of t)i(...e)},getSnapshot:r}}export{n as createEmitter};

package/esm/create-getter-state.js

@@ -1 +0,0 @@
-import{useStateValue as n}from"./use-state-value";function i(r){const{baseState:t}=r,e=(a,s)=>n(e,a,s);return e.__internal=t.__internal,e.getState=t.getState,e.reset=t.reset,e.select=t.select,e.merge=t.merge,e.subscribe=t.subscribe,e}export{i as createGetterState};

package/esm/is.js

@@ -1 +0,0 @@
-function o(n){return n instanceof Promise}function r(n){return typeof n=="function"}function u(n){return typeof n=="function"}function t(n){return typeof n=="object"&&n!==null}function i(n){return t(n)&&n.isRef===!0}function s(n){return n instanceof Map}function f(n){return n instanceof Set}function a(n){return Array.isArray(n)}function c(n,e){return n===e?!0:!!Object.is(n,e)}export{a as isArray,c as isEqualBase,r as isFunction,s as isMap,t as isObject,o as isPromise,i as isRef,f as isSet,u as isSetValueFunction};

package/esm/merge.js

@@ -1 +0,0 @@
-import{createBaseState as u}from"./create-base-state";import{createEmitter as s}from"./create-emitter";import{createGetterState as c}from"./create-getter-state";import{isEqualBase as f}from"./is";function T(t,e,i,n=f){let r;const a=s(()=>{const S=i(t.getState(),e.getState());return r!==void 0&&n(r,S)?r:(r=S,S)});t.__internal.emitter.subscribe(()=>{a.emit()}),e.__internal.emitter.subscribe(()=>{a.emit()});const o=u({emitter:a,getGetterState:()=>m,getState:()=>i(t.getState(),e.getState()),reset(){t.reset(),e.reset()}}),m=c({baseState:o});return m}export{T as merge};

package/esm/select.js

@@ -1 +0,0 @@
-import{createBaseState as m}from"./create-base-state";import{createEmitter as s}from"./create-emitter";import{createGetterState as u}from"./create-getter-state";import{isEqualBase as c}from"./is";function d(t,a,o=c){let e;const S=s(()=>{const r=a(t.getState());return e!==void 0&&o(e,r)?e:(e=r,r)});t.__internal.emitter.subscribe(()=>{S.emit()});const n=m({emitter:S,getGetterState:()=>i,getState:()=>a(t.getState()),reset:t.reset}),i=u({baseState:n});return i}export{d as select};

package/esm/shallow.js

@@ -1 +0,0 @@
-import{isArray as o,isMap as f,isSet as i}from"./is";function b(t,r){if(t==r||Object.is(t,r))return!0;if(typeof t!="object"||t==null||typeof r!="object"||r==null)return!1;if(f(t)&&f(r)){if(t.size!==r.size)return!1;for(const[n,e]of t)if(!Object.is(e,r.get(n)))return!1;return!0}if(i(t)&&i(r)){if(t.size!==r.size)return!1;for(const n of t)if(!r.has(n))return!1;return!0}if(o(t)&&o(r)){if(t.length!==r.length)return!1;for(const[n,e]of t.entries())if(!Object.is(e,r[n]))return!1;return!0}const s=Object.keys(t),c=Object.keys(r);if(s.length!==c.length)return!1;for(const n of s)if(!Object.prototype.hasOwnProperty.call(r,n)||!Object.is(t[n],r[n]))return!1;return!0}export{b as shallow};

package/esm/use-state-value.js

@@ -1 +0,0 @@
-import{useSyncExternalStore as n,toType as S}from"./common";import{isPromise as i}from"./is";function m(e,r=t=>S(t),o){const t=n(e.__internal.emitter,a=>r(a),o);if(i(t))throw t;return t}export{m as useStateValue};

package/src/common.ts

@@ -1,28 +0,0 @@
-import { useSyncExternalStoreWithSelector as useSync } from 'use-sync-external-store/shim/with-selector'
-import type { Emitter } from './create-emitter'
-import type { IsEqual } from './types'
-import { useDebugValue } from 'react'
-
-/**
- * Todo need to remove this
- */
-export function toType<T>(object?: unknown): T {
-  return object as T
-}
-
-export function useSyncExternalStore<T, S>(
-  emitter: Emitter<T>,
-  selector: (stateValue: T) => S,
-  isEqual?: IsEqual<S>,
-): undefined extends S ? T : S {
-  const value = useSync<T, S>(
-    emitter.subscribe,
-    emitter.getSnapshot,
-    emitter.getSnapshot,
-    selector ? (stateValue) => selector(stateValue) : toType,
-    isEqual,
-  ) as undefined extends S ? T : S
-
-  useDebugValue(value)
-  return value
-}

package/src/create-base-state.ts

@@ -1,35 +0,0 @@
-import type { Emitter } from './create-emitter'
-import { merge } from './merge'
-import { select } from './select'
-import type { BaseState, GetterState } from './types'
-
-interface Options<T> {
-  readonly emitter: Emitter<T>
-  readonly reset: () => void
-  readonly getState: () => T
-  readonly getGetterState: () => GetterState<T>
-}
-export function createBaseState<T>(options: Options<T>): BaseState<T> {
-  const { emitter, getGetterState, reset, getState } = options
-  return {
-    getState,
-    reset,
-    select(selector, isSame) {
-      const state = getGetterState()
-      return select(state, selector, isSame)
-    },
-    merge(state2, selector, isEqualHook) {
-      const state = getGetterState()
-      return merge(state, state2, selector, isEqualHook)
-    },
-    __internal: {
-      emitter,
-    },
-    subscribe(listener) {
-      listener(getState())
-      return emitter.subscribe(() => {
-        listener(getState())
-      })
-    },
-  }
-}