muya 1.0.1 → 1.0.3

package/src/create.ts

@@ -1,9 +1,10 @@
 import { createEmitter } from './create-emitter'
 import type { SetValue, SetterState, StateDataInternal, DefaultValue, GetterState, IsEqual, UpdateValue } from './types'
 import { getDefaultValue } from './types'
-import { isEqualBase, isObject, isPromise, isSetValueFunction } from './is'
+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.
@@ -44,19 +45,34 @@ export function create<T>(defaultValue: DefaultValue<T>, isEqual: IsEqual<T> = i
     }
     return stateData.value
   }
+
   function get(): T {
     const stateValue = getValue()
     if (isPromise(stateValue)) {
-      stateValue.then((data) => {
-        stateData.value = data as Awaited<T>
-        emitter.emit()
-      })
+      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) {
@@ -85,9 +101,18 @@ export function create<T>(defaultValue: DefaultValue<T>, isEqual: IsEqual<T> = i
     reset() {
       const value = getDefaultValue(defaultValue)
       if (isPromise(value)) {
-        value.then((data) => {
-          set(data as T)
-        })
+        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)

package/src/is.ts

@@ -1,3 +1,4 @@
+import { Abort } from './common'
 import type { Ref, Setter, SetValue } from './types'
 
 export function isPromise(value: unknown): value is Promise<unknown> {
@@ -34,3 +35,11 @@ export function isEqualBase<T>(valueA: T, valueB: T): boolean {
   }
   return !!Object.is(valueA, valueB)
 }
+
+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
+}

package/src/merge.ts

@@ -4,35 +4,32 @@ import { createGetterState } from './create-getter-state'
 import { isEqualBase } from './is'
 import type { IsEqual, GetterState } from './types'
 
-export function merge<T1, T2, S>(
-  state1: GetterState<T1>,
-  state2: GetterState<T2>,
-  selector: (value1: T1, value2: T2) => S,
+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(state1.getState(), state2.getState())
+    const data = selector(...(states.map((state) => state.getState()) as T))
     if (previousData !== undefined && isEqual(previousData, data)) {
       return previousData
     }
     previousData = data
     return data
   })
-  state1.__internal.emitter.subscribe(() => {
-    emitter.emit()
-  })
-  state2.__internal.emitter.subscribe(() => {
-    emitter.emit()
-  })
+  for (const state of states) {
+    state.__internal.emitter.subscribe(() => {
+      emitter.emit()
+    })
+  }
 
   const baseState = createBaseState<S>({
     emitter,
     getGetterState: () => getterState,
-    getState: () => selector(state1.getState(), state2.getState()),
+    getState: () => selector(...(states.map((state) => state.getState()) as T)),
     reset() {
-      state1.reset()
-      state2.reset()
+      for (const state of states) state.reset()
     },
   })
 

package/src/shallow.ts

@@ -5,9 +5,6 @@ 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

package/src/types.ts

@@ -27,6 +27,7 @@ export type GetState<T> = () => T
 export interface StateDataInternal<T = unknown> {
   value?: T
   updateVersion: number
+  abortController?: AbortController
 }
 
 // eslint-disable-next-line no-shadow
@@ -46,7 +47,6 @@ export interface BaseState<T> {
   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

package/src/use-state-value.ts

@@ -1,6 +1,6 @@
 import type { IsEqual, State } from './types'
 import { useSyncExternalStore, toType } from './common'
-import { isPromise } from './is'
+import { isAnyOtherError, isPromise } from './is'
 
 /**
  * useCachedStateValue Hook.
@@ -25,5 +25,8 @@ export function useStateValue<T, S>(
   if (isPromise(data)) {
     throw data
   }
+  if (isAnyOtherError(data)) {
+    throw data
+  }
   return data
 }

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/common.d.ts

@@ -5,3 +5,13 @@ import type { IsEqual } from './types';
  */
 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/is.d.ts

@@ -8,3 +8,5 @@ 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 isAbortError(value: unknown): value is DOMException;
+export declare function isAnyOtherError(value: unknown): value is Error;

package/types/merge.d.ts

@@ -1,2 +1,4 @@
 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>;
+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/types.d.ts

@@ -22,6 +22,7 @@ export type GetState<T> = () => T;
 export interface StateDataInternal<T = unknown> {
     value?: T;
     updateVersion: number;
+    abortController?: AbortController;
 }
 export declare enum StateKeys {
     IS_STATE = "isState",
@@ -37,7 +38,6 @@ export interface BaseState<T> {
      */
     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
      */