muya 1.0.3 → 2.0.0-beta.1

package/src/create-base-state.ts

@@ -1,31 +0,0 @@
-import type { Emitter } from './create-emitter'
-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)
-    },
-
-    __internal: {
-      emitter,
-    },
-    subscribe(listener) {
-      listener(getState())
-      return emitter.subscribe(() => {
-        listener(getState())
-      })
-    },
-  }
-}

package/src/create-emitter.ts

@@ -1,24 +0,0 @@
-export type EmitterSubscribe<P = undefined> = (listener: (...params: P[]) => void) => () => void
-export interface Emitter<T, R = T, P = undefined> {
-  subscribe: EmitterSubscribe<P>
-  getSnapshot: () => R
-  emit: (...params: P[]) => void
-}
-
-export function createEmitter<T, R = T, P = undefined>(getSnapshot: () => R): Emitter<T, R, P> {
-  const listeners = new Set<(...params: P[]) => void>()
-  return {
-    subscribe: (listener) => {
-      listeners.add(listener)
-      return () => {
-        listeners.delete(listener)
-      }
-    },
-    emit: (...params) => {
-      for (const listener of listeners) {
-        listener(...params)
-      }
-    },
-    getSnapshot,
-  }
-}

package/src/create-getter-state.ts

@@ -1,18 +0,0 @@
-import type { BaseState, GetterState } from './types'
-import { useStateValue } from './use-state-value'
-
-interface Options<T> {
-  readonly baseState: BaseState<T>
-}
-export function createGetterState<T>(options: Options<T>): GetterState<T> {
-  const { baseState } = options
-  const useSliceState: GetterState<T> = (useSelector, isEqualHook) => {
-    return useStateValue(useSliceState, useSelector, isEqualHook)
-  }
-  useSliceState.__internal = baseState.__internal
-  useSliceState.getState = baseState.getState
-  useSliceState.reset = baseState.reset
-  useSliceState.select = baseState.select
-  useSliceState.subscribe = baseState.subscribe
-  return useSliceState
-}

package/src/create.ts

@@ -1,127 +0,0 @@
-import { createEmitter } from './create-emitter'
-import type { SetValue, SetterState, StateDataInternal, DefaultValue, GetterState, IsEqual, UpdateValue } from './types'
-import { getDefaultValue } from './types'
-import { isAbortError, isEqualBase, isObject, isPromise, isSetValueFunction } from './is'
-import { createBaseState } from './create-base-state'
-import { createGetterState } from './create-getter-state'
-import { cancelablePromise } from './common'
-
-/**
- * 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 function create<T>(defaultValue: DefaultValue<T>, isEqual: IsEqual<T> = isEqualBase): SetterState<Awaited<T>> {
-  function resolveSetter(value: T, stateSetter: SetValue<T>): T {
-    if (isSetValueFunction(stateSetter)) {
-      return stateSetter(value)
-    }
-    return stateSetter
-  }
-
-  const stateData: StateDataInternal<T> = {
-    updateVersion: 0,
-    value: undefined,
-  }
-
-  function getValue(): T {
-    if (stateData.value === undefined) {
-      stateData.value = getDefaultValue(defaultValue)
-    }
-    return stateData.value
-  }
-
-  function get(): T {
-    const stateValue = getValue()
-    if (isPromise(stateValue)) {
-      const { controller, promise } = cancelablePromise(stateValue, stateData.abortController)
-      stateData.abortController = controller
-      promise
-        .then((data) => {
-          stateData.value = data as Awaited<T>
-          emitter.emit()
-        })
-        .catch((error) => {
-          if (isAbortError(error)) {
-            return
-          }
-          stateData.value = new Error(error) as T
-        })
-    }
-    return stateValue
-  }
-
-  function set(stateValue: SetValue<T>) {
-    const stateValueData = getValue()
-    if (stateData.abortController) {
-      stateData.abortController.abort()
-      stateData.abortController = undefined
-    }
-
-    const newState = resolveSetter(stateValueData, stateValue)
-    const isEqualResult = isEqual?.(stateValueData, newState)
-    if (isEqualResult || newState === stateValueData) {
-      return
-    }
-    stateData.updateVersion++
-    stateData.value = newState
-    emitter.emit()
-  }
-
-  function update(stateValue: UpdateValue<T>) {
-    if (isObject(stateValue)) {
-      return set((previousState) => {
-        return { ...previousState, ...stateValue }
-      })
-    }
-    set(stateValue as T)
-  }
-
-  const emitter = createEmitter<T>(get)
-
-  const baseState = createBaseState({
-    emitter,
-    getGetterState: () => setterState,
-    getState: get,
-    reset() {
-      const value = getDefaultValue(defaultValue)
-      if (isPromise(value)) {
-        const { controller, promise } = cancelablePromise(value, stateData.abortController)
-        stateData.abortController = controller
-        promise
-          .then((data) => {
-            set(data as T)
-          })
-          .catch((error) => {
-            if (isAbortError(error)) {
-              return
-            }
-            stateData.value = new Error(error) as T
-          })
-        return
-      }
-      set(value)
-    },
-  })
-
-  const getterState: GetterState<T> = createGetterState<T>({ baseState })
-  const setterState: SetterState<T> = getterState as SetterState<T>
-  setterState.setState = set
-  setterState.updateState = update
-  return setterState as SetterState<Awaited<T>>
-}

package/src/index.ts

@@ -1,6 +0,0 @@
-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'

package/src/merge.ts

@@ -1,38 +0,0 @@
-import { createBaseState } from './create-base-state'
-import { createEmitter } from './create-emitter'
-import { createGetterState } from './create-getter-state'
-import { isEqualBase } from './is'
-import type { IsEqual, GetterState } from './types'
-
-export function merge<T extends unknown[], S>(
-  states: { [K in keyof T]: GetterState<T[K]> },
-  selector: (...values: T) => S,
-  isEqual: IsEqual<S> = isEqualBase,
-): GetterState<S> {
-  let previousData: S | undefined
-  const emitter = createEmitter(() => {
-    const data = selector(...(states.map((state) => state.getState()) as T))
-    if (previousData !== undefined && isEqual(previousData, data)) {
-      return previousData
-    }
-    previousData = data
-    return data
-  })
-  for (const state of states) {
-    state.__internal.emitter.subscribe(() => {
-      emitter.emit()
-    })
-  }
-
-  const baseState = createBaseState<S>({
-    emitter,
-    getGetterState: () => getterState,
-    getState: () => selector(...(states.map((state) => state.getState()) as T)),
-    reset() {
-      for (const state of states) state.reset()
-    },
-  })
-
-  const getterState: GetterState<S> = createGetterState<S>({ baseState })
-  return getterState
-}

package/src/select.ts

@@ -1,33 +0,0 @@
-import { createBaseState } from './create-base-state'
-import { createEmitter } from './create-emitter'
-import { createGetterState } from './create-getter-state'
-import { isEqualBase } from './is'
-import type { IsEqual, GetterState } from './types'
-
-export function select<T, S>(
-  state: GetterState<T>,
-  selector: (value: T) => S,
-  isEqual: IsEqual<S> = isEqualBase,
-): GetterState<S> {
-  let previousData: S | undefined
-  const emitter = createEmitter(() => {
-    const data = selector(state.getState())
-    if (previousData !== undefined && isEqual(previousData, data)) {
-      return previousData
-    }
-    previousData = data
-    return data
-  })
-  state.__internal.emitter.subscribe(() => {
-    emitter.emit()
-  })
-
-  const baseState = createBaseState<S>({
-    emitter,
-    getGetterState: () => getterState,
-    getState: () => selector(state.getState()),
-    reset: state.reset,
-  })
-  const getterState: GetterState<S> = createGetterState<S>({ baseState })
-  return getterState
-}

package/src/types.ts

@@ -1,94 +0,0 @@
-import type { Emitter } from './create-emitter'
-import { isFunction, isPromise } from './is'
-
-/**
- * Equality check function.
- */
-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
-  abortController?: AbortController
-}
-
-// eslint-disable-next-line no-shadow
-export 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>
-
-  /**
-   * Internal state data
-   */
-  __internal: {
-    emitter: Emitter<T>
-  }
-
-  subscribe: (listener: (value: T) => void) => () => void
-}
-
-export interface GetterState<T> extends BaseState<T> {
-  // use use as the function call here
-  <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 DefaultValue<T> = T | (() => T)
-
-export function getDefaultValue<T>(initValue: DefaultValue<T>): T {
-  if (isPromise(initValue)) {
-    return initValue
-  }
-  if (isFunction(initValue)) {
-    return (initValue as () => T)()
-  }
-  return initValue
-}
-
-export interface Ref<T> {
-  current: T | undefined
-  readonly isRef: true
-}

package/src/use-state-value.ts

@@ -1,32 +0,0 @@
-import type { IsEqual, State } from './types'
-import { useSyncExternalStore, toType } from './common'
-import { isAnyOtherError, isPromise } from './is'
-
-/**
- * useCachedStateValue Hook.
- * Hook for use state inside react scope. If the state is async - component need to be wrapped with Suspense.
- * @param state - state value
- * @param selector - selector function (useStateValue(state, (state) => state.value)) - it return only selected value, selector don't need to be memoized.
- * @param isEqual - equality check function for selector
- * @returns StateValue from selector if provided, otherwise whole state
- */
-export function useStateValue<T, S>(
-  state: State<T>,
-  selector: (stateValue: T) => S = (stateValue) => toType<S>(stateValue),
-  isEqual?: IsEqual<S>,
-): undefined extends S ? T : S {
-  const data = useSyncExternalStore(
-    state.__internal.emitter,
-    (stateValue) => {
-      return selector(stateValue)
-    },
-    isEqual,
-  )
-  if (isPromise(data)) {
-    throw data
-  }
-  if (isAnyOtherError(data)) {
-    throw data
-  }
-  return data
-}

package/types/common.d.ts

@@ -1,17 +0,0 @@
-import type { Emitter } from './create-emitter';
-import type { IsEqual } from './types';
-/**
- * Todo need to remove this
- */
-export declare function toType<T>(object?: unknown): T;
-export declare function useSyncExternalStore<T, S>(emitter: Emitter<T>, selector: (stateValue: T) => S, isEqual?: IsEqual<S>): undefined extends S ? T : S;
-export declare enum Abort {
-    Error = "StateAbortError"
-}
-/**
- * Cancelable promise function, return promise and controller
- */
-export declare function cancelablePromise<T>(promise: Promise<T>, previousController?: AbortController): {
-    promise: Promise<T>;
-    controller: AbortController;
-};

package/types/create-base-state.d.ts

@@ -1,10 +0,0 @@
-import type { Emitter } from './create-emitter';
-import type { BaseState, GetterState } from './types';
-interface Options<T> {
-    readonly emitter: Emitter<T>;
-    readonly reset: () => void;
-    readonly getState: () => T;
-    readonly getGetterState: () => GetterState<T>;
-}
-export declare function createBaseState<T>(options: Options<T>): BaseState<T>;
-export {};

package/types/create-emitter.d.ts

@@ -1,7 +0,0 @@
-export type EmitterSubscribe<P = undefined> = (listener: (...params: P[]) => void) => () => void;
-export interface Emitter<T, R = T, P = undefined> {
-    subscribe: EmitterSubscribe<P>;
-    getSnapshot: () => R;
-    emit: (...params: P[]) => void;
-}
-export declare function createEmitter<T, R = T, P = undefined>(getSnapshot: () => R): Emitter<T, R, P>;

package/types/create-getter-state.d.ts

@@ -1,6 +0,0 @@
-import type { BaseState, GetterState } from './types';
-interface Options<T> {
-    readonly baseState: BaseState<T>;
-}
-export declare function createGetterState<T>(options: Options<T>): GetterState<T>;
-export {};

package/types/merge.d.ts

@@ -1,4 +0,0 @@
-import type { IsEqual, GetterState } from './types';
-export declare function merge<T extends unknown[], S>(states: {
-    [K in keyof T]: GetterState<T[K]>;
-}, selector: (...values: T) => S, isEqual?: IsEqual<S>): GetterState<S>;

package/types/select.d.ts

@@ -1,2 +0,0 @@
-import type { IsEqual, GetterState } from './types';
-export declare function select<T, S>(state: GetterState<T>, selector: (value: T) => S, isEqual?: IsEqual<S>): GetterState<S>;

package/types/use-state-value.d.ts

@@ -1,10 +0,0 @@
-import type { IsEqual, State } from './types';
-/**
- * useCachedStateValue Hook.
- * Hook for use state inside react scope. If the state is async - component need to be wrapped with Suspense.
- * @param state - state value
- * @param selector - selector function (useStateValue(state, (state) => state.value)) - it return only selected value, selector don't need to be memoized.
- * @param isEqual - equality check function for selector
- * @returns StateValue from selector if provided, otherwise whole state
- */
-export declare function useStateValue<T, S>(state: State<T>, selector?: (stateValue: T) => S, isEqual?: IsEqual<S>): undefined extends S ? T : S;