coaction 0.0.1 → 0.1.0

package/dist/coaction.cjs.d.mts

@@ -0,0 +1,2 @@
+export * from "./declarations/src/index.js";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29hY3Rpb24uY2pzLmQubXRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi9kZWNsYXJhdGlvbnMvc3JjL2luZGV4LmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEifQ==

package/dist/coaction.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./declarations/src/index";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29hY3Rpb24uY2pzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuL2RlY2xhcmF0aW9ucy9zcmMvaW5kZXguZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSJ9

package/dist/coaction.cjs.js

@@ -0,0 +1,661 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var mutative = require('mutative');
+var dataTransport = require('data-transport');
+
+const getGlobal = () => {
+  let _global;
+  if (typeof window !== 'undefined') {
+    _global = window;
+  } else if (typeof global !== 'undefined') {
+    _global = global;
+  } else if (typeof self !== 'undefined') {
+    _global = self;
+  } else {
+    _global = {};
+  }
+  return _global;
+};
+const _global = getGlobal();
+
+const WorkerType = _global.SharedWorkerGlobalScope ? 'SharedWorkerInternal' : globalThis.WorkerGlobalScope ? 'WebWorkerInternal' : null;
+const bindSymbol = Symbol('bind');
+const defaultName = 'default';
+
+const createAsyncClientStore = (createStore, asyncStoreClientOption) => {
+  const {
+    store: asyncClientStore
+  } = createStore({
+    share: 'client'
+  });
+  // the transport is in the worker or shared worker, and the client is in the main thread.
+  // This store can't be directly executed by any of the store's methods
+  // its methods are proxied to the worker or share worker for execution.
+  // and the executed patch is sent to the store to be applied to synchronize the state.
+  const transport = asyncStoreClientOption.worker ? dataTransport.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;
+  let sequence;
+  const fullSync = async () => {
+    const latest = await transport.emit('fullSync');
+    asyncClientStore.apply(JSON.parse(latest.state));
+    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 === sequence + 1) {
+      sequence = options.sequence;
+      asyncClientStore.apply(undefined, options.patches);
+    } else {
+      await fullSync();
+    }
+  });
+  const {
+    name,
+    ..._store
+  } = asyncClientStore;
+  return Object.assign({
+    [name]: () => asyncClientStore.getState()
+  }[name], _store);
+};
+const emit = (store, internal, patches) => {
+  if (store.transport && patches?.length) {
+    internal.sequence += 1;
+    // it is not necessary to respond to the update event
+    store.transport.emit({
+      name: 'update',
+      respond: false
+    }, {
+      patches: patches,
+      sequence: internal.sequence
+    });
+  }
+};
+const 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);
+    // 3rd party model will send update notifications on its own after `store.apply` in mutableInstance mode
+    emit(store, internal, finalPatches.patches);
+  }
+};
+
+const getInitialState = (store, createState) => {
+  const makeState = fn => {
+    // make sure createState is a function
+    if (process.env.NODE_ENV !== 'production' && typeof fn !== 'function') {
+      throw new Error('createState should be a function');
+    }
+    let state = fn(store.setState, store.getState, store);
+    if (typeof state === 'function') {
+      state = state();
+    }
+    if (state[bindSymbol]) {
+      const rawState = state[bindSymbol].bind(state);
+      state[bindSymbol].handleStore(store, rawState, state);
+      return rawState;
+    }
+    return state;
+  };
+  return store.isSliceStore ? Object.entries(createState).reduce((stateTree, [key, value]) => Object.assign(stateTree, {
+    [key]: makeState(value)
+  }), {}) : makeState(createState);
+};
+
+const isEqual = (x, y) => {
+  if (x === y) {
+    return x !== 0 || y !== 0 || 1 / x === 1 / y;
+  }
+  return x !== x && y !== y;
+};
+const 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;
+};
+const 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);
+  }
+};
+const uuid = () => {
+  let timestamp = new Date().getTime();
+  const uuidTemplate = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
+  const uuid = uuidTemplate.replace(/[xy]/g, char => {
+    let randomNum = (timestamp + Math.random() * 16) % 16 | 0;
+    timestamp = Math.floor(timestamp / 16);
+    return (char === 'x' ? randomNum : randomNum & 0x3 | 0x8).toString(16);
+  });
+  return uuid;
+};
+
+class Computed {
+  constructor(deps, fn) {
+    this.deps = deps;
+    this.fn = fn;
+  }
+}
+const defaultMemoize = func => {
+  const lastArgs = new WeakMap();
+  const lastResult = 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);
+  };
+};
+const 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]));
+    };
+  };
+};
+const createSelectorWithArray = createSelectorCreatorWithArray();
+
+const getRawState = (store, internal, initialState, options) => {
+  const rawState = {};
+  const handle = (_rawState, _initialState, sliceKey) => {
+    internal.mutableInstance = store.toRaw?.(_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');
+            }
+            // manually handle computed property
+            const {
+              deps,
+              fn
+            } = descriptor.value;
+            const depsCallbackSelector = createSelectorWithArray(() => [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;
+              };
+            }
+          }
+          // handle state property
+          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];
+            // emit the action to worker or main thread execute
+            return store.transport.emit('execute', keys, args).then(result => {
+              if (result?.$$Error) {
+                done?.(result);
+                throw new Error(result.$$Error);
+              }
+              done?.(result);
+              return 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 = result => {
+                store.trace({
+                  method: key,
+                  id: actionId,
+                  result,
+                  sliceKey
+                });
+              };
+            }
+            const enablePatches = store.transport ?? options.enablePatches;
+            if (internal.mutableInstance && !internal.isBatching && enablePatches) {
+              let result;
+              const handleResult = isDrafted => {
+                handleDraft(store, internal);
+                if (isDrafted) {
+                  internal.backupState = internal.rootState;
+                  const [draft, finalize] = mutative.create(internal.rootState, {
+                    enablePatches: true
+                  });
+                  internal.finalizeDraft = finalize;
+                  internal.rootState = draft;
+                }
+              };
+              const isDrafted = mutative.isDraft(internal.rootState);
+              if (isDrafted) {
+                handleResult();
+              }
+              internal.backupState = internal.rootState;
+              const [draft, finalize] = mutative.create(internal.rootState, {
+                enablePatches: true
+              });
+              internal.finalizeDraft = finalize;
+              internal.rootState = draft;
+              try {
+                result = fn.apply(sliceKey ? store.getState()[sliceKey] : store.getState(), args);
+              } finally {
+                if (result instanceof Promise) {
+                  // if (process.env.NODE_ENV === 'development') {
+                  //   console.warn(
+                  //     'It will be combined with the next state in the async function.'
+                  //   );
+                  // }
+                  return result.finally(() => {
+                    const result = handleResult(isDrafted);
+                    done?.(result);
+                    return result;
+                  });
+                }
+                handleResult(isDrafted);
+              }
+              done?.(result);
+              return result;
+            }
+            if (internal.mutableInstance && store.act) {
+              const result = store.act(() => {
+                return fn.apply(sliceKey ? store.getState()[sliceKey] : store.getState(), args);
+              });
+              done?.(result);
+              return result;
+            }
+            const result = fn.apply(sliceKey ? store.getState()[sliceKey] : store.getState(), args);
+            done?.(result);
+            return result;
+          };
+        }
+      }
+    });
+    // it should be a immutable state
+    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;
+};
+
+const handleState = (store, internal, options) => {
+  const setState = (next, updater = next => {
+    const merge = (_next = next) => {
+      mergeObject(internal.rootState, _next, store.isSliceStore);
+    };
+    const fn = typeof next === 'function' ? () => {
+      const returnValue = next(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) {
+      if (internal.mutableInstance) {
+        if (store.act) {
+          store.act(() => {
+            fn.apply(null);
+          });
+          return [];
+        }
+        fn.apply(null);
+        return [];
+      }
+      // best performance by default for immutable state
+      // TODO: supporting nested set functions?
+      try {
+        internal.backupState = internal.rootState;
+        internal.rootState = mutative.create(internal.rootState, draft => {
+          internal.rootState = draft;
+          return fn.apply(null);
+        });
+      } catch (error) {
+        internal.rootState = internal.backupState;
+        throw error;
+      }
+      internal.listeners.forEach(listener => listener());
+      return [];
+    }
+    internal.backupState = internal.rootState;
+    let patches;
+    let inversePatches;
+    try {
+      const result = mutative.create(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) {
+        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;
+    let result;
+    try {
+      const isDrafted = internal.mutableInstance && mutative.isDraft(internal.rootState);
+      if (isDrafted) {
+        handleDraft(store, internal);
+      }
+      result = updater(next);
+      if (isDrafted) {
+        internal.backupState = internal.rootState;
+        const [draft, finalize] = mutative.create(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
+  };
+};
+
+const applyMiddlewares = (store, middlewares) => {
+  return middlewares.reduce((store, middleware, index) => {
+    if (process.env.NODE_ENV === 'development') {
+      if (typeof middleware !== 'function') {
+        throw new Error(`middlewares[${index}] should be a function`);
+      }
+    }
+    return middleware(store);
+  }, store);
+};
+
+/**
+ * wrapStore is a function to wrap the store and return function to get the state with store.
+ */
+const wrapStore = (store, getState = () => store.getState()) => {
+  const {
+    name,
+    ..._store
+  } = store;
+  return Object.assign({
+    [name]: (...args) => getState(...args)
+  }[name], _store);
+};
+
+const handleMainTransport = (store, internal, storeTransport, workerType, checkEnablePatches) => {
+  // store transport for server port
+  // the store transport is responsible for transmitting the sync state to the client transport.
+  const transport = storeTransport ?? (workerType === 'SharedWorkerInternal' || workerType === 'WebWorkerInternal' ? dataTransport.createTransport(workerType, {
+    prefix: store.name
+  }) : undefined);
+  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;
+    for (const key of keys) {
+      base = base[key];
+      if (typeof base === 'function') {
+        base = base.bind(obj);
+      }
+      obj = base;
+    }
+    if (process.env.NODE_ENV === 'development' && typeof base !== 'function') {
+      throw new Error('The function is not found');
+    }
+    try {
+      return base(...args);
+    } catch (error) {
+      console.error(error);
+      return {
+        $$Error: error.message
+      };
+    }
+  });
+  transport.listen('fullSync', async () => {
+    return {
+      state: JSON.stringify(internal.rootState),
+      sequence: internal.sequence
+    };
+  });
+  store.transport = transport;
+};
+
+const namespaceMap = new Map();
+
+/**
+ * Create a simple store or a shared store. The shared store can be used in a worker or another thread.
+ */
+const 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' : undefined;
+  const createStore = ({
+    share
+  }) => {
+    const store = {};
+    const internal = {
+      sequence: 0,
+      isBatching: false,
+      listeners: new Set()
+    };
+    const name = options.name ?? defaultName;
+    // check if the store name is unique in main share mode
+    if (process.env.NODE_ENV === 'development' && share === 'main') {
+      if (namespaceMap.get(name)) {
+        throw new Error(`Store name '${name}' is not unique.`);
+      }
+      namespaceMap.set(name, true);
+    }
+    const {
+      setState,
+      getState
+    } = handleState(store, internal, options);
+    const subscribe = listener => {
+      internal.listeners.add(listener);
+      return () => internal.listeners.delete(listener);
+    };
+    const destroy = () => {
+      internal.listeners.clear();
+      store.transport?.dispose();
+    };
+    const apply = (state = internal.rootState, patches) => {
+      internal.rootState = patches ? mutative.apply(state, patches) : state;
+      internal.listeners.forEach(listener => listener());
+    };
+    const getPureState = () => internal.rootState;
+    const isSliceStore = typeof createState === 'object';
+    Object.assign(store, {
+      name,
+      share: share ?? false,
+      setState,
+      getState,
+      subscribe,
+      destroy,
+      apply,
+      isSliceStore,
+      getPureState
+    });
+    applyMiddlewares(store, options.middlewares ?? []);
+    const initialState = getInitialState(store, createState);
+    store.getInitialState = () => initialState;
+    internal.rootState = getRawState(store, internal, initialState, options);
+    return {
+      store,
+      internal
+    };
+  };
+  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 store = createAsyncClientStore(createStore, options);
+    return wrapStore(store);
+  }
+  const {
+    store,
+    internal
+  } = createStore({
+    share
+  });
+  handleMainTransport(store, internal, storeTransport, workerType, checkEnablePatches);
+  return wrapStore(store);
+};
+
+/**
+ * createBinder is a function to create a binder for the 3rd party store.
+ */
+function createBinder({
+  handleState,
+  handleStore
+}) {
+  return state => {
+    const {
+      copyState,
+      key,
+      bind
+    } = handleState(state);
+    const value = key ? copyState[key] : copyState;
+    value[bindSymbol] = {
+      handleStore,
+      bind
+    };
+    return copyState;
+  };
+}
+
+exports.create = create;
+exports.createBinder = createBinder;
+exports.wrapStore = wrapStore;

package/dist/coaction.cjs.mjs

@@ -0,0 +1,5 @@
+export {
+  create,
+  createBinder,
+  wrapStore
+} from "./coaction.cjs.js";