coaction 0.1.4 → 0.2.0

package/dist/index.mjs

@@ -0,0 +1,818 @@
+// src/create.ts
+import { apply as applyWithMutative } from "mutative";
+
+// src/global.ts
+var getGlobal = () => {
+  let _global2;
+  if (typeof window !== "undefined") {
+    _global2 = window;
+  } else if (typeof global !== "undefined") {
+    _global2 = global;
+  } else if (typeof self !== "undefined") {
+    _global2 = self;
+  } else {
+    _global2 = {};
+  }
+  return _global2;
+};
+var _global = getGlobal();
+
+// src/constant.ts
+var WorkerType = _global.SharedWorkerGlobalScope ? "SharedWorkerInternal" : globalThis.WorkerGlobalScope ? "WebWorkerInternal" : null;
+var bindSymbol = /* @__PURE__ */ Symbol("bind");
+var defaultName = "default";
+
+// src/asyncClientStore.ts
+import { createTransport } from "data-transport";
+
+// src/wrapStore.ts
+var wrapStore = (store, getState = () => store.getState()) => {
+  const { name, ..._store } = store;
+  return Object.assign(
+    {
+      [name]: (...args) => getState(...args)
+    }[name],
+    _store
+  );
+};
+
+// src/asyncClientStore.ts
+var createAsyncClientStore = (createStore, asyncStoreClientOption) => {
+  const { store: asyncClientStore, internal } = createStore({
+    share: "client"
+  });
+  const transport = asyncStoreClientOption.worker ? createTransport(
+    asyncStoreClientOption.worker instanceof SharedWorker ? "SharedWorkerClient" : "WebWorkerClient",
+    {
+      worker: asyncStoreClientOption.worker,
+      prefix: asyncClientStore.name
+    }
+  ) : asyncStoreClientOption.clientTransport;
+  if (!transport) {
+    throw new Error("transport is required");
+  }
+  asyncClientStore.transport = transport;
+  const fullSync = async () => {
+    const latest = await transport.emit("fullSync");
+    asyncClientStore.apply(JSON.parse(latest.state));
+    internal.sequence = latest.sequence;
+  };
+  if (typeof transport.onConnect !== "function") {
+    throw new Error("transport.onConnect is required");
+  }
+  transport.onConnect?.(async () => {
+    await fullSync();
+  });
+  transport.listen("update", async (options) => {
+    if (typeof options.sequence === "number" && options.sequence === internal.sequence + 1) {
+      internal.sequence = options.sequence;
+      asyncClientStore.apply(void 0, options.patches);
+    } else {
+      await fullSync();
+    }
+  });
+  return wrapStore(asyncClientStore, () => asyncClientStore.getState());
+};
+var emit = (store, internal, patches) => {
+  if (store.transport && patches?.length) {
+    internal.sequence += 1;
+    store.transport.emit(
+      {
+        name: "update",
+        respond: false
+      },
+      {
+        patches,
+        sequence: internal.sequence
+      }
+    );
+  }
+};
+var handleDraft = (store, internal) => {
+  internal.rootState = internal.backupState;
+  const [, patches, inversePatches] = internal.finalizeDraft();
+  const finalPatches = store.patch ? store.patch({ patches, inversePatches }) : { patches, inversePatches };
+  if (finalPatches.patches.length) {
+    store.apply(internal.rootState, finalPatches.patches);
+    emit(store, internal, finalPatches.patches);
+  }
+};
+
+// src/getInitialState.ts
+var isObject = (value) => typeof value === "object" && value !== null;
+var isStateFactory = (value) => typeof value === "function";
+var hasGetState = (value) => (typeof value === "object" || typeof value === "function") && value !== null && typeof value.getState === "function";
+var hasBindState = (value) => isObject(value) && !!value[bindSymbol];
+var getInitialState = (store, createState, internal) => {
+  const makeState = (stateOrFn, key) => {
+    let state;
+    if (isStateFactory(stateOrFn)) {
+      state = stateOrFn(store.setState, store.getState, store);
+    } else if (isObject(stateOrFn)) {
+      state = stateOrFn;
+    } else {
+      if (process.env.NODE_ENV !== "production") {
+        throw new Error(
+          `Invalid state value encountered in makeState: ${key ? `for key ${key}, ` : ""}${typeof stateOrFn}`
+        );
+      }
+      return {};
+    }
+    if (hasGetState(state)) {
+      state = state.getState();
+    } else if (typeof state === "function") {
+      state = state();
+    }
+    if (hasBindState(state)) {
+      if (store.isSliceStore) {
+        throw new Error(
+          "Third-party state binding does not support Slices mode. Please inject a whole store instead."
+        );
+      }
+      const binder = state[bindSymbol];
+      const rawState = binder.bind(state);
+      binder.handleStore(
+        store,
+        rawState,
+        state,
+        internal,
+        key
+      );
+      delete state[bindSymbol];
+      return rawState;
+    }
+    return state;
+  };
+  return store.isSliceStore ? Object.entries(createState).reduce(
+    (stateTree, [key, value]) => Object.assign(stateTree, {
+      [key]: makeState(value, key)
+    }),
+    {}
+  ) : makeState(createState);
+};
+
+// src/getRawState.ts
+import {
+  create as createWithMutative,
+  isDraft
+} from "mutative";
+
+// src/utils.ts
+var isEqual = (x, y) => {
+  if (x === y) {
+    return x !== 0 || y !== 0 || 1 / x === 1 / y;
+  }
+  return x !== x && y !== y;
+};
+var areShallowEqualWithArray = (prev, next) => {
+  if (prev === null || next === null || prev.length !== next.length) {
+    return false;
+  }
+  const { length } = prev;
+  for (let i = 0; i < length; i += 1) {
+    if (!isEqual(prev[i], next[i])) {
+      return false;
+    }
+  }
+  return true;
+};
+var mergeObject = (target, source, isSlice) => {
+  if (isSlice) {
+    if (typeof source === "object" && source !== null) {
+      for (const key in source) {
+        if (typeof source[key] === "object" && source[key] !== null) {
+          Object.assign(target[key], source[key]);
+        }
+      }
+    }
+  } else {
+    Object.assign(target, source);
+  }
+};
+var uuid = () => {
+  let timestamp = (/* @__PURE__ */ new Date()).getTime();
+  const uuidTemplate = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
+  const uuid2 = uuidTemplate.replace(/[xy]/g, (char) => {
+    let randomNum = (timestamp + Math.random() * 16) % 16 | 0;
+    timestamp = Math.floor(timestamp / 16);
+    return (char === "x" ? randomNum : randomNum & 3 | 8).toString(16);
+  });
+  return uuid2;
+};
+
+// src/computed.ts
+var Computed = class {
+  constructor(deps, fn) {
+    this.deps = deps;
+    this.fn = fn;
+  }
+};
+var defaultMemoize = (func) => {
+  const lastArgs = /* @__PURE__ */ new WeakMap();
+  const lastResult = /* @__PURE__ */ new WeakMap();
+  return function() {
+    if (!areShallowEqualWithArray(lastArgs.get(this) ?? [], arguments)) {
+      lastResult.set(this, func.apply(this, arguments));
+    }
+    lastArgs.set(this, arguments);
+    return lastResult.get(this);
+  };
+};
+var createSelectorCreatorWithArray = (memoize = defaultMemoize) => {
+  return (dependenciesFunc, resultFunc) => {
+    const memoizedResultFunc = memoize(function() {
+      return resultFunc.apply(this, arguments);
+    });
+    return function() {
+      return memoizedResultFunc.apply(
+        this,
+        dependenciesFunc.apply(null, [this])
+      );
+    };
+  };
+};
+var createSelectorWithArray = createSelectorCreatorWithArray();
+
+// src/getRawState.ts
+var getRawState = (store, internal, initialState, options) => {
+  const rawState = {};
+  const handle = (_rawState, _initialState, sliceKey) => {
+    internal.mutableInstance = internal.toMutableRaw?.(_initialState);
+    const descriptors = Object.getOwnPropertyDescriptors(_initialState);
+    Object.entries(descriptors).forEach(([key, descriptor]) => {
+      if (Object.prototype.hasOwnProperty.call(descriptor, "value")) {
+        if (typeof descriptor.value !== "function") {
+          const isComputed = descriptor.value instanceof Computed;
+          if (internal.mutableInstance) {
+            Object.defineProperty(_rawState, key, {
+              get: () => internal.mutableInstance[key],
+              set: (value) => {
+                internal.mutableInstance[key] = value;
+              },
+              enumerable: true
+            });
+          } else if (!isComputed) {
+            _rawState[key] = descriptor.value;
+          }
+          if (isComputed) {
+            if (internal.mutableInstance) {
+              throw new Error(
+                "Computed is not supported with mutable instance"
+              );
+            }
+            const { deps, fn } = descriptor.value;
+            const depsCallbackSelector = createSelectorWithArray(
+              // the root state should be updated, and the computed property will be updated.
+              () => [internal.rootState],
+              () => {
+                return deps(internal.module);
+              }
+            );
+            const selector = createSelectorWithArray(
+              (that) => depsCallbackSelector.call(that),
+              fn
+            );
+            descriptor.get = function() {
+              return selector.call(this);
+            };
+          } else {
+            if (sliceKey) {
+              descriptor.get = () => internal.rootState[sliceKey][key];
+              descriptor.set = (value) => {
+                internal.rootState[sliceKey][key] = value;
+              };
+            } else {
+              descriptor.get = () => internal.rootState[key];
+              descriptor.set = (value) => {
+                internal.rootState[key] = value;
+              };
+            }
+          }
+          delete descriptor.value;
+          delete descriptor.writable;
+        } else if (store.share === "client") {
+          descriptor.value = (...args) => {
+            let actionId;
+            let done;
+            if (store.trace) {
+              actionId = uuid();
+              store.trace({
+                method: key,
+                parameters: args,
+                id: actionId,
+                sliceKey
+              });
+              done = (result) => {
+                store.trace({
+                  method: key,
+                  id: actionId,
+                  result,
+                  sliceKey
+                });
+              };
+            }
+            const keys = sliceKey ? [sliceKey, key] : [key];
+            return store.transport.emit("execute", keys, args).then(([result, sequence]) => {
+              if (internal.sequence >= sequence) {
+                if (result?.$$Error) {
+                  done?.(result);
+                  throw new Error(result.$$Error);
+                }
+                done?.(result);
+                return result;
+              }
+              if (process.env.NODE_ENV === "development") {
+                console.warn(
+                  `The sequence of the action is not consistent.`,
+                  sequence,
+                  internal.sequence
+                );
+              }
+              return new Promise((resolve) => {
+                const unsubscribe = store.subscribe(() => {
+                  if (internal.sequence >= sequence) {
+                    unsubscribe();
+                    done?.(result);
+                    resolve(result);
+                  }
+                });
+              });
+            });
+          };
+        } else {
+          const fn = descriptor.value;
+          descriptor.value = (...args) => {
+            let actionId;
+            let done;
+            if (store.trace) {
+              actionId = uuid();
+              store.trace({
+                method: key,
+                parameters: args,
+                id: actionId,
+                sliceKey
+              });
+              done = (result2) => {
+                store.trace({
+                  method: key,
+                  id: actionId,
+                  result: result2,
+                  sliceKey
+                });
+              };
+            }
+            const enablePatches = store.transport ?? options.enablePatches;
+            if (internal.mutableInstance && !internal.isBatching && enablePatches) {
+              let result2;
+              const handleResult = (isDrafted2) => {
+                handleDraft(store, internal);
+                if (isDrafted2) {
+                  internal.backupState = internal.rootState;
+                  const [draft2, finalize2] = createWithMutative(
+                    internal.rootState,
+                    {
+                      enablePatches: true
+                    }
+                  );
+                  internal.finalizeDraft = finalize2;
+                  internal.rootState = draft2;
+                }
+              };
+              const isDrafted = isDraft(internal.rootState);
+              if (isDrafted) {
+                handleResult();
+              }
+              internal.backupState = internal.rootState;
+              const [draft, finalize] = createWithMutative(internal.rootState, {
+                enablePatches: true
+              });
+              internal.finalizeDraft = finalize;
+              internal.rootState = draft;
+              try {
+                result2 = fn.apply(
+                  sliceKey ? store.getState()[sliceKey] : store.getState(),
+                  args
+                );
+              } finally {
+                if (result2 instanceof Promise) {
+                  return result2.finally(() => {
+                    const result3 = handleResult(isDrafted);
+                    done?.(result3);
+                    return result3;
+                  });
+                }
+                handleResult(isDrafted);
+              }
+              done?.(result2);
+              return result2;
+            }
+            if (internal.mutableInstance && internal.actMutable) {
+              const result2 = internal.actMutable(() => {
+                return fn.apply(
+                  sliceKey ? store.getState()[sliceKey] : store.getState(),
+                  args
+                );
+              });
+              done?.(result2);
+              return result2;
+            }
+            const result = fn.apply(
+              sliceKey ? store.getState()[sliceKey] : store.getState(),
+              args
+            );
+            done?.(result);
+            return result;
+          };
+        }
+      }
+    });
+    const slice = Object.defineProperties({}, descriptors);
+    return slice;
+  };
+  if (store.isSliceStore) {
+    internal.module = {};
+    Object.entries(initialState).forEach(([key, value]) => {
+      rawState[key] = {};
+      internal.module[key] = handle(rawState[key], value, key);
+    });
+  } else {
+    internal.module = handle(rawState, initialState);
+  }
+  return rawState;
+};
+
+// src/handleState.ts
+import {
+  create as createWithMutative2,
+  isDraft as isDraft2
+} from "mutative";
+var handleState = (store, internal, options) => {
+  const setState = (next, updater = (next2) => {
+    const merge = (_next = next2) => {
+      mergeObject(internal.rootState, _next, store.isSliceStore);
+    };
+    const fn = typeof next2 === "function" ? () => {
+      const returnValue = next2(internal.module);
+      if (returnValue instanceof Promise) {
+        throw new Error(
+          "setState with async function is not supported"
+        );
+      }
+      if (typeof returnValue === "object" && returnValue !== null) {
+        merge(returnValue);
+      }
+    } : merge;
+    const enablePatches = store.transport ?? options.enablePatches;
+    if (!enablePatches && internal.mutableInstance) {
+      if (internal.actMutable) {
+        internal.actMutable(() => {
+          fn.apply(null);
+        });
+        return [];
+      }
+      fn.apply(null);
+      return [];
+    }
+    internal.backupState = internal.rootState;
+    let patches;
+    let inversePatches;
+    try {
+      const result = createWithMutative2(
+        internal.rootState,
+        (draft) => {
+          internal.rootState = draft;
+          return fn.apply(null);
+        },
+        {
+          enablePatches: true
+        }
+      );
+      patches = result[1];
+      inversePatches = result[2];
+    } finally {
+      internal.rootState = internal.backupState;
+    }
+    const finalPatches = store.patch ? store.patch({ patches, inversePatches }) : { patches, inversePatches };
+    if (finalPatches.patches.length) {
+      store.apply(internal.rootState, finalPatches.patches);
+      if (!internal.mutableInstance) {
+        if (internal.updateImmutable) {
+          internal.updateImmutable(internal.rootState);
+        } else {
+          internal.listeners.forEach((listener) => listener());
+        }
+      }
+    }
+    return [internal.rootState, patches, inversePatches];
+  }) => {
+    if (store.share === "client") {
+      throw new Error(
+        `setState() cannot be called in the client store. To update the state, please trigger a store method with setState() instead.`
+      );
+    }
+    if (internal.isBatching) {
+      throw new Error("setState cannot be called within the updater");
+    }
+    internal.isBatching = true;
+    if (!store.share && !options.enablePatches && !internal.mutableInstance) {
+      if (typeof next === "function") {
+        try {
+          internal.backupState = internal.rootState;
+          internal.rootState = createWithMutative2(
+            internal.rootState,
+            (draft) => {
+              internal.rootState = draft;
+              return next(internal.module);
+            }
+          );
+        } catch (error) {
+          internal.rootState = internal.backupState;
+          internal.isBatching = false;
+          throw error;
+        }
+      } else {
+        const copy = {};
+        const rootState = internal.rootState;
+        for (const key of Object.keys(rootState)) {
+          copy[key] = rootState[key];
+        }
+        for (const key of Object.keys(next)) {
+          copy[key] = next[key];
+        }
+        internal.rootState = copy;
+      }
+      if (internal.updateImmutable) {
+        internal.updateImmutable(internal.rootState);
+      } else {
+        internal.listeners.forEach((listener) => listener());
+      }
+      internal.isBatching = false;
+      return [];
+    }
+    let result;
+    try {
+      const isDrafted = internal.mutableInstance && isDraft2(internal.rootState);
+      if (isDrafted) {
+        handleDraft(store, internal);
+      }
+      result = updater(next);
+      if (isDrafted) {
+        internal.backupState = internal.rootState;
+        const [draft, finalize] = createWithMutative2(
+          internal.rootState,
+          {
+            enablePatches: true
+          }
+        );
+        internal.finalizeDraft = finalize;
+        internal.rootState = draft;
+      }
+    } finally {
+      internal.isBatching = false;
+    }
+    emit(store, internal, result?.[1]);
+    return result;
+  };
+  const getState = (deps, selector) => deps && selector ? new Computed(deps, selector) : internal.module;
+  return { setState, getState };
+};
+
+// src/applyMiddlewares.ts
+var isStoreLike = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.setState === "function" && typeof candidate.getState === "function" && typeof candidate.subscribe === "function" && typeof candidate.destroy === "function" && typeof candidate.apply === "function" && typeof candidate.getPureState === "function";
+};
+var applyMiddlewares = (store, middlewares) => {
+  return middlewares.reduce((store2, middleware, index) => {
+    if (process.env.NODE_ENV === "development") {
+      if (typeof middleware !== "function") {
+        throw new Error(`middlewares[${index}] should be a function`);
+      }
+    }
+    const nextStore = middleware(store2);
+    if (process.env.NODE_ENV === "development") {
+      if (!isStoreLike(nextStore)) {
+        throw new Error(
+          `middlewares[${index}] should return a store-like object`
+        );
+      }
+    }
+    return nextStore;
+  }, store);
+};
+
+// src/handleMainTransport.ts
+import { createTransport as createTransport2 } from "data-transport";
+var getErrorMessage = (error) => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+};
+var handleMainTransport = (store, internal, storeTransport, workerType, checkEnablePatches) => {
+  const transport = storeTransport ?? (workerType === "SharedWorkerInternal" || workerType === "WebWorkerInternal" ? createTransport2(workerType, {
+    prefix: store.name
+  }) : void 0);
+  if (!transport) return;
+  if (typeof transport.onConnect !== "function") {
+    throw new Error("transport.onConnect is required");
+  }
+  if (checkEnablePatches) {
+    throw new Error(`enablePatches: true is required for the transport`);
+  }
+  transport.listen("execute", async (keys, args) => {
+    let base = store.getState();
+    let obj = base;
+    try {
+      for (const key of keys) {
+        base = base[key];
+        if (typeof base === "function") {
+          base = base.bind(obj);
+        }
+        obj = base;
+      }
+      if (typeof base !== "function") {
+        throw new Error("The function is not found");
+      }
+      return [base(...args), internal.sequence];
+    } catch (error) {
+      if (process.env.NODE_ENV === "development") {
+        console.error(error);
+      }
+      return [{ $$Error: getErrorMessage(error) }, internal.sequence];
+    }
+  });
+  transport.listen("fullSync", async () => {
+    return {
+      state: JSON.stringify(internal.rootState),
+      sequence: internal.sequence
+    };
+  });
+  store.transport = transport;
+};
+
+// src/create.ts
+var namespaceMap = /* @__PURE__ */ new Map();
+var create = (createState, options = {}) => {
+  const checkEnablePatches = Object.hasOwnProperty.call(options, "enablePatches") && !options.enablePatches;
+  const workerType = options.workerType ?? WorkerType;
+  if (process.env.NODE_ENV === "development" && options.transport && options.clientTransport) {
+    throw new Error(
+      `transport and clientTransport cannot be used together, please use one of them.`
+    );
+  }
+  const storeTransport = options.transport;
+  const share = workerType === "WebWorkerInternal" || workerType === "SharedWorkerInternal" || storeTransport ? "main" : void 0;
+  const createStore = ({ share: share2 }) => {
+    const store2 = {};
+    const internal2 = {
+      sequence: 0,
+      isBatching: false,
+      listeners: /* @__PURE__ */ new Set()
+    };
+    const name = options.name ?? defaultName;
+    const shouldTrackName = process.env.NODE_ENV === "development" && share2 === "main";
+    const releaseStoreName = () => {
+      if (shouldTrackName) {
+        namespaceMap.delete(name);
+      }
+    };
+    if (shouldTrackName) {
+      if (namespaceMap.get(name)) {
+        throw new Error(`Store name '${name}' is not unique.`);
+      }
+      namespaceMap.set(name, true);
+    }
+    try {
+      const { setState, getState } = handleState(store2, internal2, options);
+      const subscribe = (listener) => {
+        internal2.listeners.add(listener);
+        return () => internal2.listeners.delete(listener);
+      };
+      let isDestroyed = false;
+      const destroy = () => {
+        if (isDestroyed) {
+          return;
+        }
+        isDestroyed = true;
+        internal2.listeners.clear();
+        store2.transport?.dispose();
+        releaseStoreName();
+      };
+      const apply = (state = internal2.rootState, patches) => {
+        internal2.rootState = patches ? applyWithMutative(state, patches) : state;
+        if (internal2.updateImmutable) {
+          internal2.updateImmutable(internal2.rootState);
+        } else {
+          internal2.listeners.forEach((listener) => listener());
+        }
+      };
+      const getPureState = () => internal2.rootState;
+      const inferSliceStore = () => {
+        if (typeof createState === "object" && createState !== null) {
+          const values = Object.values(createState);
+          return values.length > 0 && values.every((value) => typeof value === "function");
+        }
+        return false;
+      };
+      const isValidSliceObject = () => {
+        if (typeof createState !== "object" || createState === null) {
+          return false;
+        }
+        const values = Object.values(createState);
+        return values.length > 0 && values.every((value) => typeof value === "function");
+      };
+      const getIsSliceStore = () => {
+        const sliceMode = options.sliceMode ?? "auto";
+        if (sliceMode === "single") {
+          return false;
+        }
+        if (sliceMode === "slices") {
+          if (!isValidSliceObject()) {
+            throw new Error(
+              `sliceMode: 'slices' requires createState to be an object of slice functions.`
+            );
+          }
+          return true;
+        }
+        return inferSliceStore();
+      };
+      const isSliceStore = getIsSliceStore();
+      Object.assign(store2, {
+        name,
+        share: share2 ?? false,
+        setState,
+        getState,
+        subscribe,
+        destroy,
+        apply,
+        isSliceStore,
+        getPureState
+      });
+      const middlewareStore = applyMiddlewares(
+        store2,
+        options.middlewares ?? []
+      );
+      if (middlewareStore !== store2) {
+        Object.assign(store2, middlewareStore);
+      }
+      const initialState = getInitialState(store2, createState, internal2);
+      store2.getInitialState = () => initialState;
+      internal2.rootState = getRawState(
+        store2,
+        internal2,
+        initialState,
+        options
+      );
+      return { store: store2, internal: internal2 };
+    } catch (error) {
+      releaseStoreName();
+      throw error;
+    }
+  };
+  if (options.clientTransport || options.worker || options.workerType === "WebWorkerClient" || options.workerType === "SharedWorkerClient") {
+    if (checkEnablePatches) {
+      throw new Error(`enablePatches: true is required for the async store`);
+    }
+    const store2 = createAsyncClientStore(
+      createStore,
+      options
+    );
+    return wrapStore(store2);
+  }
+  const { store, internal } = createStore({
+    share
+  });
+  handleMainTransport(
+    store,
+    internal,
+    storeTransport,
+    workerType,
+    checkEnablePatches
+  );
+  return wrapStore(store);
+};
+
+// src/binder.ts
+function createBinder({
+  handleState: handleState2,
+  handleStore
+}) {
+  return ((state) => {
+    const { copyState, key, bind } = handleState2(state);
+    const value = key ? copyState[key] : copyState;
+    value[bindSymbol] = {
+      handleStore,
+      bind
+    };
+    return copyState;
+  });
+}
+export {
+  create,
+  createBinder,
+  wrapStore
+};