@astrogate/sdk 0.0.0-stage → 0.1.0

package/node_modules/mutative/src/set.ts

@@ -0,0 +1,201 @@
+import { ProxyDraft } from './interface';
+import { dataTypes, iteratorPrototype, iteratorSymbol } from './constant';
+import { internal } from './internal';
+import {
+  assertDraftActive,
+  ensureShallowCopy,
+  getProxyDraft,
+  getSetMap,
+  isDraftable,
+  iterateSet,
+  latest,
+  markChanged,
+  markFinalization,
+  setItemValue,
+} from './utils';
+import { checkReadable } from './unsafe';
+
+// A Set draft adds and deletes items in its copy, which holds the items in
+// order. `setMap` maps the original items that an iterator drafted to their
+// drafts, and the objects that the recipe added, drafts among them, to
+// themselves. Finalization replaces the drafts with their final values.
+
+const getNextIterator =
+  (
+    target: ProxyDraft<any>,
+    iterator: IterableIterator<any>,
+    isValuesIterator: boolean
+  ) =>
+  () => {
+    const result = iterator.next();
+    if (result.done) return result;
+    assertDraftActive(target);
+    const key = result.value as any;
+    let value = setItemValue(target, key);
+    const currentDraft = getProxyDraft(value);
+    const mutable =
+      target.options.mark?.(value, dataTypes) === dataTypes.mutable;
+    if (target.options.strict) {
+      checkReadable(key, target.options, mutable);
+    }
+    // Only an original item still mapped to itself needs a draft. Preserve
+    // copies when this mapping has already been finalized.
+    if (
+      !mutable &&
+      !currentDraft &&
+      value === key &&
+      isDraftable(key, target.options) &&
+      !target.finalized &&
+      target.original!.has(key)
+    ) {
+      // draft a draftable original set item
+      const proxy = internal.createDraft(
+        key,
+        target,
+        key,
+        target.finalities,
+        target.options
+      );
+      getSetMap(target).set(key, proxy);
+      value = proxy;
+    } else if (currentDraft) {
+      // drafted
+      value = currentDraft.proxy;
+    }
+    return {
+      done: false,
+      value: isValuesIterator ? value : [value, value],
+    };
+  };
+
+export const setHandler = {
+  get size() {
+    return latest(getProxyDraft(this)!).size;
+  },
+  has(value: any) {
+    const items: Set<any> = latest(getProxyDraft(this)!);
+    let valueProxyDraft: ProxyDraft | null;
+    // The value itself, which may be a draft that its producer revoked, or the
+    // item that a draft of it stands for.
+    return (
+      items.has(value) ||
+      (!!(valueProxyDraft = getProxyDraft(value)) &&
+        items.has(valueProxyDraft.original))
+    );
+  },
+  add(value: any) {
+    const target = getProxyDraft(this)!;
+    if (!this.has(value)) {
+      ensureShallowCopy(target);
+      markChanged(target);
+      target.assignedMap!.set(value, true);
+      target.copy!.add(value);
+      // An added draft is replaced by its final value when finalizing, and an
+      // added object is finalized for the drafts it may hold.
+      if (value && typeof value === 'object')
+        getSetMap(target).set(value, value);
+      markFinalization(target, value, value);
+    }
+    return this;
+  },
+  delete(value: any): boolean {
+    if (!this.has(value)) {
+      return false;
+    }
+    const target = getProxyDraft(this)!;
+    ensureShallowCopy(target);
+    markChanged(target);
+    const copy: Set<any> = target.copy!;
+    const valueProxyDraft = getProxyDraft(value);
+    // A draft of an item stands for the item; an added draft is an item.
+    const item =
+      valueProxyDraft && copy.has(valueProxyDraft.original)
+        ? valueProxyDraft.original
+        : value;
+    if (valueProxyDraft && item === value) {
+      // reassigned
+      target.assignedMap!.delete(value);
+    } else {
+      target.assignedMap!.set(item, false);
+    }
+    if (target.setMap) target.setMap.delete(item);
+    return copy.delete(item);
+  },
+  clear() {
+    if (!this.size) return;
+    const target = getProxyDraft(this)!;
+    ensureShallowCopy(target);
+    markChanged(target);
+    for (const value of target.original) {
+      target.assignedMap!.set(value, false);
+    }
+    if (target.setMap) target.setMap.clear();
+    target.copy!.clear();
+  },
+  values(): IterableIterator<any> {
+    const target = getProxyDraft(this)!;
+    ensureShallowCopy(target);
+    const iterator = iterateSet(target.copy!);
+    return {
+      __proto__: iteratorPrototype,
+      next: getNextIterator(target, iterator, true),
+    } as any;
+  },
+  entries(): IterableIterator<[any, any]> {
+    const target = getProxyDraft(this)!;
+    ensureShallowCopy(target);
+    const iterator = iterateSet(target.copy!);
+    return {
+      __proto__: iteratorPrototype,
+      next: getNextIterator(
+        target,
+        iterator,
+        false
+      ) as () => IteratorReturnResult<any>,
+    } as any;
+  },
+  keys(): IterableIterator<any> {
+    return this.values();
+  },
+  [iteratorSymbol]() {
+    return this.values();
+  },
+  forEach(callback: any, thisArg?: any) {
+    const iterator = this.values();
+    let result = iterator.next();
+    while (!result.done) {
+      callback.call(thisArg, result.value, result.value, this);
+      result = iterator.next();
+    }
+  },
+};
+
+if ('difference' in Set.prototype) {
+  // for compatibility with new Set methods
+  // https://github.com/tc39/proposal-set-methods
+  // And `https://github.com/tc39/proposal-set-methods/blob/main/details.md#symbolspecies` has some details about the `@@species` symbol.
+  // So we can't use SubSet instance constructor to get the constructor of the SubSet instance.
+  (
+    [
+      'intersection',
+      'union',
+      'difference',
+      'symmetricDifference',
+      'isSubsetOf',
+      'isSupersetOf',
+      'isDisjointFrom',
+    ] as const
+  ).forEach((method) => {
+    (setHandler as any)[method] = function (
+      this: Set<any>,
+      other: ReadonlySetLike<any>
+    ) {
+      return (Set.prototype[method] as Function).call(
+        new Set(this.values()),
+        other
+      );
+    };
+  });
+}
+
+export const setHandlerKeys = Reflect.ownKeys(setHandler);

package/node_modules/mutative/src/unsafe.ts

@@ -0,0 +1,66 @@
+import { Options } from './interface';
+import { isDraftable } from './utils';
+import { die, ErrorCode } from './error';
+
+let readable = false;
+
+export const checkReadable = (
+  value: any,
+  options: Options<any, any>,
+  ignoreCheckDraftable = false
+) => {
+  if (
+    typeof value === 'object' &&
+    value !== null &&
+    (!isDraftable(value, options) || ignoreCheckDraftable) &&
+    !readable
+  ) {
+    die(ErrorCode.StrictModeAccess);
+  }
+};
+
+// Whether reads from drafts are checked now: in strict mode, outside
+// `unsafe()`.
+export const checksReads = (options: Options<any, any>) =>
+  !!options.strict && !readable;
+
+/**
+ * `unsafe(callback)` to access mutable data directly in strict mode.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { create, unsafe } from 'mutative';
+ *
+ * class Foobar {
+ *   bar = 1;
+ * }
+ *
+ * const baseState = { foobar: new Foobar() };
+ * const state = create(
+ *   baseState,
+ *   (draft) => {
+ *    unsafe(() => {
+ *      draft.foobar.bar = 2;
+ *    });
+ *   },
+ *   {
+ *     strict: true,
+ *   }
+ * );
+ *
+ * expect(state).toBe(baseState);
+ * expect(state.foobar).toBe(baseState.foobar);
+ * expect(state.foobar.bar).toBe(2);
+ * ```
+ */
+export function unsafe<T>(callback: () => T): T {
+  // A nested call hands the outer call's access back when it ends.
+  const previous = readable;
+  readable = true;
+  try {
+    return callback();
+  } finally {
+    readable = previous;
+  }
+}

package/node_modules/mutative/src/utils/cast.ts

@@ -0,0 +1,22 @@
+import { Draft, Immutable } from '../interface';
+
+/**
+ * Cast a value to its draft type; it returns the value as it is.
+ */
+export function castDraft<T>(value: T): Draft<T> {
+  return value as any;
+}
+
+/**
+ * Cast a value to its immutable type, without freezing it.
+ */
+export function castImmutable<T>(value: T): Immutable<T> {
+  return value as any;
+}
+
+/**
+ * Cast a draft to the type of its base state.
+ */
+export function castMutable<T>(draft: Draft<T>): T {
+  return draft as any;
+}

package/node_modules/mutative/src/utils/copy.ts

@@ -0,0 +1,224 @@
+import type { Options, ProxyDraft } from '../interface';
+import { dataTypes } from '../constant';
+import { getValue, isDraft, isDraftable, iterateSet } from './draft';
+import { isBaseMapInstance, isBaseSetInstance, isPlainArray } from './proto';
+import { die, ErrorCode } from '../error';
+
+function strictCopy(target: any) {
+  const copy = Object.create(Object.getPrototypeOf(target));
+  Reflect.ownKeys(target).forEach((key: any) => {
+    let desc = Reflect.getOwnPropertyDescriptor(target, key)!;
+    // An assignment to `__proto__` would set the prototype of the copy, so an
+    // own `__proto__` key, as `JSON.parse()` creates one, is defined instead.
+    if (
+      key !== '__proto__' &&
+      desc.enumerable &&
+      desc.configurable &&
+      desc.writable
+    ) {
+      copy[key] = target[key];
+      return;
+    }
+    // for freeze
+    if (!desc.writable) {
+      desc.writable = true;
+      desc.configurable = true;
+    }
+    if (desc.get || desc.set)
+      desc = {
+        configurable: true,
+        writable: true,
+        enumerable: desc.enumerable,
+        value: target[key],
+      };
+    Reflect.defineProperty(copy, key, desc);
+  });
+  return copy;
+}
+
+const propIsEnum = Object.prototype.propertyIsEnumerable;
+
+/**
+ * Plain objects with at most this many own enumerable string keys are copied
+ * with object spread, which V8 clones in one step. Wider objects are copied
+ * key by key into a dictionary-mode object: a map transition per key is far
+ * slower there, and whether V8 stays in fast mode depends on transitions that
+ * other code may have created for the same key sequence.
+ */
+const SPREAD_KEY_LIMIT = 128;
+
+function copyPlainObject(original: any) {
+  const keys = Object.keys(original);
+  if (keys.length <= SPREAD_KEY_LIMIT) {
+    // Own enumerable string and symbol keys, like the loop below.
+    return { ...original };
+  }
+  const copy: Record<string | symbol, any> = {};
+  // Deleting a property that is not the last one switches the object to
+  // dictionary mode, so the wide copy inserts in constant time per key.
+  copy.a = 1;
+  copy.b = 1;
+  delete copy.a;
+  delete copy.b;
+  for (let index = 0; index < keys.length; index += 1) {
+    const key = keys[index];
+    if (key === '__proto__') {
+      // An own `__proto__` key (e.g. from JSON.parse) must stay a data
+      // property instead of changing the copy's prototype.
+      Object.defineProperty(copy, key, {
+        value: original[key],
+        writable: true,
+        enumerable: true,
+        configurable: true,
+      });
+    } else {
+      copy[key] = original[key];
+    }
+  }
+  const symbols = Object.getOwnPropertySymbols(original);
+  for (let index = 0; index < symbols.length; index += 1) {
+    const key = symbols[index];
+    if (propIsEnum.call(original, key)) {
+      copy[key] = original[key];
+    }
+  }
+  return copy;
+}
+
+// Copies an array with `concat`, which keeps holes and creates the copy
+// through `Symbol.species`. `concat` puts an array whose
+// `Symbol.isConcatSpreadable` is false into the copy as one element instead,
+// so such an array is copied with `slice`.
+function concatCopy(original: any[]) {
+  const copy = Array.prototype.concat.call(original);
+  return copy.length === 1 && copy[0] === original
+    ? Array.prototype.slice.call(original)
+    : copy;
+}
+
+const arrayValues = Array.prototype[Symbol.iterator];
+const arrayIterator = Object.getPrototypeOf(arrayValues.call([]));
+const arrayIteratorNext = arrayIterator.next;
+
+/**
+ * `concat` leaves V8's fast path for frozen, sealed and non-extensible arrays
+ * and takes about ten times as long as a spread there. A spread copies a
+ * plain array the same way when it has no holes and none of the iterators it
+ * calls has been replaced. Holes read as `undefined`, so arrays that hold
+ * `undefined` keep `concat`.
+ */
+function copyLockedArray(original: any[]) {
+  return isPlainArray(original) &&
+    !Object.prototype.hasOwnProperty.call(original, Symbol.iterator) &&
+    Array.prototype[Symbol.iterator] === arrayValues &&
+    arrayIterator.next === arrayIteratorNext &&
+    !Array.prototype.includes.call(original, undefined)
+    ? [...original]
+    : concatCopy(original);
+}
+
+export function shallowCopy(original: any, options?: Options<any, any>) {
+  let markResult: any;
+  if (Array.isArray(original)) {
+    // With auto-freeze, the arrays of a state are frozen; otherwise checking
+    // for that would cost more than it saves.
+    return options?.enableAutoFreeze && !Object.isExtensible(original)
+      ? copyLockedArray(original)
+      : concatCopy(original);
+  } else if (original instanceof Set) {
+    if (!isBaseSetInstance(original)) {
+      const SubClass = Object.getPrototypeOf(original).constructor;
+      const copy = new SubClass(original.values());
+      // The copy of a Set draft holds the original items in their order,
+      // whatever the subclass's constructor or `add` does with them.
+      Set.prototype.clear.call(copy);
+      for (const item of iterateSet(original))
+        Set.prototype.add.call(copy, item);
+      return copy;
+    }
+    // The Set draft of an outer create() call has no Set internals.
+    return !isDraft(original) && Set.prototype.difference
+      ? Set.prototype.difference.call(original, new Set())
+      : new Set(original.values());
+  } else if (original instanceof Map) {
+    if (!isBaseMapInstance(original)) {
+      const SubClass = Object.getPrototypeOf(original).constructor;
+      return new SubClass(original);
+    }
+    return new Map(original);
+  } else if (
+    options?.mark &&
+    ((markResult = options.mark(original, dataTypes)),
+    markResult !== undefined) &&
+    markResult !== dataTypes.mutable
+  ) {
+    if (markResult === dataTypes.immutable) {
+      return strictCopy(original);
+    } else if (typeof markResult === 'function') {
+      if (__DEV__ && (options.enablePatches || options.enableAutoFreeze)) {
+        throw new Error(
+          `You can't use mark and patches or auto freeze together.`
+        );
+      }
+      return markResult();
+    }
+    die(ErrorCode.UnsupportedMarkResult, markResult);
+  } else if (
+    typeof original === 'object' &&
+    Object.getPrototypeOf(original) === Object.prototype
+  ) {
+    return copyPlainObject(original);
+  } else {
+    die(ErrorCode.InvalidMark);
+  }
+}
+
+export function ensureShallowCopy(target: ProxyDraft) {
+  if (target.copy) return;
+  target.copy = shallowCopy(target.original, target.options)!;
+}
+
+function deepClone<T>(target: T): T;
+function deepClone(target: any) {
+  if (!isDraftable(target)) return getValue(target);
+  if (Array.isArray(target)) return target.map(deepClone);
+  if (target instanceof Map) {
+    const iterable = Array.from(target.entries()).map(([k, v]) => [
+      k,
+      deepClone(v),
+    ]) as Iterable<readonly [any, any]>;
+    if (!isBaseMapInstance(target)) {
+      const SubClass = Object.getPrototypeOf(target).constructor;
+      return new SubClass(iterable);
+    }
+    return new Map(iterable);
+  }
+  if (target instanceof Set) {
+    const iterable = Array.from(target).map(deepClone);
+    if (!isBaseSetInstance(target)) {
+      const SubClass = Object.getPrototypeOf(target).constructor;
+      return new SubClass(iterable);
+    }
+    return new Set(iterable);
+  }
+  // Own enumerable string and symbol keys, as drafts copy plain objects. The
+  // spread keeps an own `__proto__` key a data property, and assignments to
+  // the copy's own keys cannot change its prototype.
+  const copy = { ...target };
+  for (const key in copy) {
+    const value = copy[key];
+    if (typeof value === 'object' && value !== null) {
+      copy[key] = deepClone(value);
+    }
+  }
+  const symbols = Object.getOwnPropertySymbols(copy);
+  for (let index = 0; index < symbols.length; index += 1) {
+    const value = copy[symbols[index]];
+    if (typeof value === 'object' && value !== null) {
+      copy[symbols[index]] = deepClone(value);
+    }
+  }
+  return copy;
+}
+
+export { deepClone };

package/node_modules/mutative/src/utils/deepFreeze.ts

@@ -0,0 +1,103 @@
+import { DraftType } from '../interface';
+import { getType, isDraft } from './draft';
+import { die, ErrorCode } from '../error';
+
+function throwFrozenError() {
+  die(ErrorCode.CannotModifyFrozenObject);
+}
+
+function isFreezable(value: any) {
+  return (
+    __DEV__ || (value && typeof value === 'object' && !Object.isFrozen(value))
+  );
+}
+
+export function deepFreeze(
+  target: any,
+  subKey?: any,
+  stack?: any[],
+  keys?: any[]
+) {
+  if (__DEV__) {
+    stack = stack ?? [];
+    keys = keys ?? [];
+    // A cycle is an object that holds itself through its values. The copy of a
+    // changed draft is a different object from its original, so a copy that
+    // holds its original, as `draft.prev = original(draft)` makes it, is no
+    // cycle, and neither is a shared object reached through another path.
+    if (stack.length > 0) {
+      const index = stack.indexOf(target);
+      if (target && typeof target === 'object' && index !== -1) {
+        if (stack[0] === target) {
+          throw new Error(`Forbids circular reference`);
+        }
+        throw new Error(
+          `Forbids circular reference: ~/${keys
+            .slice(0, index)
+            .map((key, index) => {
+              if (typeof key === 'symbol') return `[${key.toString()}]`;
+              const parent = stack![index];
+              if (
+                typeof key === 'object' &&
+                (parent instanceof Map || parent instanceof Set)
+              )
+                return Array.from(parent.keys()).indexOf(key);
+              return key;
+            })
+            .join('/')}`
+        );
+      }
+      stack.push(target);
+      keys.push(subKey);
+    } else {
+      stack.push(target);
+    }
+  }
+  if (Object.isFrozen(target) || isDraft(target)) {
+    if (__DEV__) {
+      stack!.pop();
+      keys!.pop();
+    }
+    return;
+  }
+  const type = getType(target);
+  // Like other objects, a Map or Set is frozen before its contents, so that a
+  // later freeze skips it and a circular reference ends the walk. Freezing
+  // leaves its entries mutable, which the guards installed first prevent.
+  switch (type) {
+    case DraftType.Map:
+      target.set = target.clear = target.delete = throwFrozenError;
+      Object.freeze(target);
+      for (const [key, value] of target) {
+        if (isFreezable(key)) deepFreeze(key, key, stack, keys);
+        if (isFreezable(value)) deepFreeze(value, key, stack, keys);
+      }
+      break;
+    case DraftType.Set:
+      target.add = target.clear = target.delete = throwFrozenError;
+      Object.freeze(target);
+      for (const value of target) {
+        if (isFreezable(value)) deepFreeze(value, value, stack, keys);
+      }
+      break;
+    case DraftType.Array:
+      Object.freeze(target);
+      let index = 0;
+      for (const value of target) {
+        if (isFreezable(value)) deepFreeze(value, index, stack, keys);
+        index += 1;
+      }
+      break;
+    default:
+      Object.freeze(target);
+      // ignore non-enumerable or symbol properties
+      Object.keys(target).forEach((name) => {
+        const value = target[name];
+        if (isFreezable(value)) deepFreeze(value, name, stack, keys);
+      });
+  }
+  if (__DEV__) {
+    stack!.pop();
+    keys!.pop();
+  }
+}