coaction 0.1.4 → 0.2.0

package/dist/coaction.esm.js

@@ -1,655 +0,0 @@
-import { isDraft, create as create$1, apply } from 'mutative';
-import { createTransport } from '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 ? 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] = create$1(internal.rootState, {
-                    enablePatches: true
-                  });
-                  internal.finalizeDraft = finalize;
-                  internal.rootState = draft;
-                }
-              };
-              const isDrafted = isDraft(internal.rootState);
-              if (isDrafted) {
-                handleResult();
-              }
-              internal.backupState = internal.rootState;
-              const [draft, finalize] = create$1(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 = create$1(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 = create$1(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 && isDraft(internal.rootState);
-      if (isDrafted) {
-        handleDraft(store, internal);
-      }
-      result = updater(next);
-      if (isDrafted) {
-        internal.backupState = internal.rootState;
-        const [draft, finalize] = create$1(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' ? 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$1 = (state = internal.rootState, patches) => {
-      internal.rootState = patches ? 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: apply$1,
-      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;
-  };
-}
-
-export { create, createBinder, wrapStore };