muya 1.1.0

package/src/types.ts

@@ -0,0 +1,94 @@
+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
+}
+
+// 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>
+  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> {
+  // 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

@@ -0,0 +1,29 @@
+import type { IsEqual, State } from './types'
+import { useSyncExternalStore, toType } from './common'
+import { 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
+  }
+  return data
+}

package/types/common.d.ts

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

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

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

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

@@ -0,0 +1,6 @@
+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/create.d.ts

@@ -0,0 +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>>;

package/types/index.d.ts

@@ -0,0 +1,6 @@
+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/types/is.d.ts

@@ -0,0 +1,10 @@
+import type { Ref, Setter, SetValue } from './types';
+export declare function isPromise(value: unknown): value is Promise<unknown>;
+export declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
+export declare function isSetValueFunction<T>(value: SetValue<T>): value is Setter<T>;
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+export declare function isRef<T>(value: unknown): value is Ref<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;

package/types/merge.d.ts

@@ -0,0 +1,2 @@
+import type { IsEqual, GetterState } from './types';
+export declare function merge<T1, T2, S>(state1: GetterState<T1>, state2: GetterState<T2>, selector: (value1: T1, value2: T2) => S, isEqual?: IsEqual<S>): GetterState<S>;

package/types/select.d.ts

@@ -0,0 +1,2 @@
+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/shallow.d.ts

@@ -0,0 +1 @@
+export declare function shallow<T>(valueA: T, valueB: T): boolean;

package/types/types.d.ts

@@ -0,0 +1,68 @@
+import type { Emitter } from './create-emitter';
+/**
+ * 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;
+}
+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 DefaultValue<T> = T | (() => T);
+export declare function getDefaultValue<T>(initValue: DefaultValue<T>): T;
+export interface Ref<T> {
+    current: T | undefined;
+    readonly isRef: true;
+}

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

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