@astrogate/sdk 0.0.0-stage → 0.1.0

package/node_modules/mutative/src/map.ts

@@ -0,0 +1,160 @@
+import type { ProxyDraft } from './interface';
+import { dataTypes, iteratorPrototype, iteratorSymbol } from './constant';
+import { internal } from './internal';
+import { checkReadable } from './unsafe';
+import {
+  assertDraftActive,
+  ensureShallowCopy,
+  getProxyDraft,
+  isDraftable,
+  isEqual,
+  latest,
+  markChanged,
+  markFinalization,
+} from './utils';
+
+// The value at `key` as `get()` returns it: a draft of a draftable value of
+// the original Map. Iteration calls this with the draft state it looked up
+// once, instead of calling `get()` through the proxy, which binds a new
+// function for every entry.
+function getEntry(target: ProxyDraft, key: any) {
+  const value = latest(target).get(key);
+  const mutable = target.options.mark?.(value, dataTypes) === dataTypes.mutable;
+  if (target.options.strict) {
+    checkReadable(value, target.options, mutable);
+  }
+  if (mutable) {
+    return value;
+  }
+  if (target.finalized || !isDraftable(value, target.options)) {
+    return value;
+  }
+  // drafted or reassigned
+  if (value !== target.original.get(key)) {
+    return value;
+  }
+  const draft = internal.createDraft(
+    value,
+    target,
+    key,
+    target.finalities,
+    target.options
+  );
+  ensureShallowCopy(target);
+  target.copy.set(key, draft);
+  return draft;
+}
+
+export const mapHandler = {
+  get size() {
+    const current: Map<any, any> = latest(getProxyDraft(this)!);
+    return current.size;
+  },
+  has(key: any): boolean {
+    return latest(getProxyDraft(this)!).has(key);
+  },
+  set(key: any, value: any) {
+    // Map keys are used as they are, and a draft is revoked when its producer
+    // ends, so a Map would keep a key that throws when it is read.
+    if (__DEV__) {
+      let isDraftKey = false;
+      try {
+        isDraftKey = !!getProxyDraft(key);
+      } catch {
+        // Map keys are compared by identity only, so a key can also be a Proxy
+        // that rejects reading the symbol of drafts, or a revoked one.
+      }
+      if (isDraftKey) {
+        throw new Error(
+          `A draft cannot be a Map key: its producer revokes it when it ends. Use original(key), current(key) or an id as the key; see https://mutative.js.org/docs/extra-topics/faq`
+        );
+      }
+    }
+    const target = getProxyDraft(this)!;
+    const source = latest(target);
+    if (!source.has(key) || !isEqual(source.get(key), value)) {
+      ensureShallowCopy(target);
+      markChanged(target);
+      target.assignedMap!.set(key, true);
+      target.copy.set(key, value);
+      markFinalization(target, key, value);
+    }
+    return this;
+  },
+  delete(key: any): boolean {
+    if (!this.has(key)) {
+      return false;
+    }
+    const target = getProxyDraft(this)!;
+    ensureShallowCopy(target);
+    markChanged(target);
+    if (target.original.has(key)) {
+      target.assignedMap!.set(key, false);
+    } else {
+      target.assignedMap!.delete(key);
+    }
+    target.copy.delete(key);
+    return true;
+  },
+  clear() {
+    const target = getProxyDraft(this)!;
+    if (!this.size) return;
+    ensureShallowCopy(target);
+    markChanged(target);
+    target.assignedMap = new Map();
+    for (const [key] of target.original) {
+      target.assignedMap.set(key, false);
+    }
+    target.copy!.clear();
+  },
+  forEach(callback: (value: any, key: any, self: any) => void, thisArg?: any) {
+    const target = getProxyDraft(this)!;
+    latest(target).forEach((_value: any, key: any) => {
+      assertDraftActive(target);
+      callback.call(thisArg, getEntry(target, key), key, this);
+    });
+  },
+  get(key: any): any {
+    return getEntry(getProxyDraft(this)!, key);
+  },
+  keys(): IterableIterator<any> {
+    return latest(getProxyDraft(this)!).keys();
+  },
+  values(): IterableIterator<any> {
+    const target = getProxyDraft(this)!;
+    const iterator = this.keys();
+    return {
+      __proto__: iteratorPrototype,
+      next: () => {
+        const result = iterator.next();
+        if (result.done) return result;
+        assertDraftActive(target);
+        return {
+          done: false,
+          value: getEntry(target, result.value),
+        };
+      },
+    } as any;
+  },
+  entries(): IterableIterator<[any, any]> {
+    const target = getProxyDraft(this)!;
+    const iterator = this.keys();
+    return {
+      __proto__: iteratorPrototype,
+      next: () => {
+        const result = iterator.next();
+        if (result.done) return result;
+        assertDraftActive(target);
+        return {
+          done: false,
+          value: [result.value, getEntry(target, result.value)],
+        };
+      },
+    } as any;
+  },
+  [iteratorSymbol]() {
+    return this.entries();
+  },
+};
+
+export const mapHandlerKeys = Reflect.ownKeys(mapHandler);

package/node_modules/mutative/src/original.ts

@@ -0,0 +1,28 @@
+import { getProxyDraft } from './utils';
+import { die, ErrorCode } from './error';
+
+/**
+ * `original(draft)` to get original state in the draft mutation function.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { create, original } from 'mutative';
+ *
+ * const baseState = { foo: { bar: 'str' }, arr: [] };
+ * const state = create(
+ *   baseState,
+ *   (draft) => {
+ *     draft.foo.bar = 'str2';
+ *     expect(original(draft.foo)).toEqual({ bar: 'str' });
+ *   }
+ * );
+ * ```
+ */
+export function original<T>(target: T): T {
+  const proxyDraft = getProxyDraft(target);
+  if (!proxyDraft) {
+    die(ErrorCode.OriginalOnNonDraft, target);
+  }
+  return proxyDraft.original;
+}

package/node_modules/mutative/src/patch.ts

@@ -0,0 +1,386 @@
+import { DraftType, Operation, Patches, ProxyDraft } from './interface';
+import {
+  checkPathKey,
+  escapePath,
+  get,
+  getProxyDraft,
+  getType,
+  has,
+  isEqual,
+} from './utils';
+import { current } from './current';
+
+/**
+ * Patch values must not contain drafts. A draft that is still present when its
+ * container generates patches is represented by its original object when it
+ * was not modified, or by a snapshot of its current state otherwise.
+ */
+function cloneIfNeeded<T>(target: T): T {
+  const proxyDraft = getProxyDraft(target);
+  if (!proxyDraft) return target;
+  return proxyDraft.operated ? current(target as any) : proxyDraft.original;
+}
+
+const hasOwn = Object.prototype.hasOwnProperty;
+
+// In Node.js 24, checking an index takes about 7 ns, or 30 ns in a
+// dictionary-mode array, and enumerating an own key about 150 ns. A suffix is
+// checked index by index until this many holes have passed, and the rest of a
+// long gap is crossed by enumerating own keys.
+const SPARSE_HOLE_LIMIT = 65536;
+
+// Patches that restore the own indices of `to` from `start` on, including
+// non-enumerable ones. `indices`, if given, holds all of them, among others,
+// in ascending order.
+function restoreSuffix(
+  to: any[],
+  start: number,
+  indices: number[] | null,
+  basePath: any[],
+  result: Patches,
+  pathAsArray: boolean
+) {
+  const restore = (index: number) =>
+    result.push({
+      op: Operation.Replace,
+      path: escapePath(basePath.concat([index]), pathAsArray),
+      value: cloneIfNeeded(to[index]),
+    });
+  if (indices !== null) {
+    for (let position = 0; position < indices.length; position += 1) {
+      const index = indices[position];
+      if (index >= start && index < to.length && hasOwn.call(to, index)) {
+        restore(index);
+      }
+    }
+    return;
+  }
+  let index = start;
+  let holes = 0;
+  while (index < to.length && holes <= SPARSE_HOLE_LIMIT) {
+    if (hasOwn.call(to, index)) restore(index);
+    else holes += 1;
+    index += 1;
+  }
+  if (index === to.length) return;
+  // Array indices only, not length or custom properties such as '1.5'.
+  for (const key of Object.getOwnPropertyNames(to)) {
+    const own = Number(key);
+    if (
+      Number.isInteger(own) &&
+      own >= index &&
+      own < to.length &&
+      String(own) === key
+    ) {
+      restore(own);
+    }
+  }
+}
+
+// Index patches carry values, so neither an undefined value nor an index
+// removal can represent a hole. Patches that turn an own index of `from` into
+// a hole of `to` rebuild the suffix from there: they truncate it, grow the
+// length to leave holes, then restore only own indices. Filling a hole takes
+// an index patch, so only that direction rebuilds. Keeping the array itself
+// supports mutable application and arrays inside Sets. `indices`, when known,
+// holds every own index that `to` has from `start` on.
+function rebuildSuffix(
+  from: any[],
+  to: any[],
+  start: number,
+  indices: number[] | null,
+  basePath: any[],
+  result: Patches,
+  pathAsArray: boolean,
+  arrayLengthAssignment: boolean
+) {
+  const lengthPath = escapePath(basePath.concat(['length']), pathAsArray);
+  const cut = Math.min(start, to.length);
+  if (arrayLengthAssignment) {
+    if (from.length > cut) {
+      result.push({ op: Operation.Replace, path: lengthPath, value: cut });
+    }
+  } else {
+    for (let index = from.length - 1; index >= cut; index -= 1) {
+      result.push({
+        op: Operation.Remove,
+        path: escapePath(basePath.concat([index]), pathAsArray),
+      });
+    }
+  }
+  if (to.length <= cut) return;
+  // JSON cannot encode holes. Growing a sparse array needs a length patch
+  // even when shrinking arrays use per-index removals.
+  result.push({
+    op: Operation.Replace,
+    path: lengthPath,
+    value: to.length,
+  });
+  restoreSuffix(to, cut, indices, basePath, result, pathAsArray);
+}
+
+function generateArrayPatches(
+  proxyState: ProxyDraft<Array<any>>,
+  basePath: any[],
+  patches: Patches,
+  inversePatches: Patches,
+  pathAsArray: boolean
+) {
+  let { original, assignedMap, options } = proxyState;
+  let copy = proxyState.copy!;
+  const { arrayLengthAssignment = true } = options.enablePatches;
+  const shorter = copy.length < original.length;
+  if (shorter) {
+    [original, copy] = [copy, original];
+    [patches, inversePatches] = [inversePatches, patches];
+  }
+  // Only assigned indices and the range touched by native array operations
+  // can differ, so visit those in ascending order instead of scanning every
+  // element of a possibly very large array.
+  const arrayState = proxyState.arrayState;
+  const diffStart = arrayState === null ? 0 : arrayState.diffStart;
+  const diffEnd = arrayState === null ? 0 : arrayState.diffEnd;
+  const assigned: number[] = [];
+  assignedMap!.forEach((flag, key) => {
+    if (flag && key !== 'length') {
+      const index = Number(key);
+      if (index < diffStart || index >= diffEnd) assigned.push(index);
+    }
+  });
+  assigned.sort((a, b) => a - b);
+  // Assigned indices below the range, the range itself, then the rest.
+  const indices: number[] = [];
+  let position = 0;
+  for (
+    ;
+    position < assigned.length && assigned[position] < diffStart;
+    position += 1
+  ) {
+    indices.push(assigned[position]);
+  }
+  for (let index = diffStart; index < diffEnd; index += 1) indices.push(index);
+  for (; position < assigned.length; position += 1)
+    indices.push(assigned[position]);
+  // The first index at which each direction turns an own index into a hole.
+  let forward = -1;
+  let inverse = -1;
+  for (let position = 0; position < indices.length; position += 1) {
+    const index = indices[position];
+    if (index >= original.length) break;
+    const value = copy[index];
+    const previous = original[index];
+    // A hole reads as `undefined`.
+    let inCopy = true;
+    let inOriginal = true;
+    if (value === undefined || previous === undefined) {
+      inCopy = hasOwn.call(copy, index);
+      inOriginal = hasOwn.call(original, index);
+    }
+    // As the set trap compares, so 0 and -0 differ and NaN equals itself.
+    if (inCopy !== inOriginal || !isEqual(value, previous)) {
+      const _path = basePath.concat([index]);
+      const path = escapePath(_path, pathAsArray);
+      if (forward === -1) {
+        if (inCopy) {
+          patches.push({
+            op: Operation.Replace,
+            path,
+            value: cloneIfNeeded(value),
+          });
+        } else {
+          forward = index;
+        }
+      }
+      if (inverse === -1) {
+        if (inOriginal) {
+          inversePatches.push({
+            op: Operation.Replace,
+            path,
+            value: cloneIfNeeded(previous),
+          });
+        } else {
+          inverse = index;
+        }
+      }
+      if (forward !== -1 && inverse !== -1) break;
+    }
+  }
+  if (forward === -1) {
+    for (let index = original.length; index < copy.length; index += 1) {
+      const value = copy[index];
+      if (value === undefined && !hasOwn.call(copy, index)) {
+        forward = index;
+        break;
+      }
+      const _path = basePath.concat([index]);
+      const path = escapePath(_path, pathAsArray);
+      patches.push({
+        op: Operation.Add,
+        path,
+        // If it is a draft, it needs to be deep cloned, and it may also be non-draft.
+        value: cloneIfNeeded(value),
+      });
+    }
+  }
+  if (forward !== -1) {
+    // Every index that the copy has past the end of the original was set by
+    // the recipe, so `indices` holds it. A shorter copy was swapped, which
+    // makes `copy` the original array.
+    rebuildSuffix(
+      original,
+      copy,
+      forward,
+      shorter || forward < original.length ? null : indices,
+      basePath,
+      patches,
+      pathAsArray,
+      arrayLengthAssignment
+    );
+  }
+  if (inverse !== -1) {
+    rebuildSuffix(
+      copy,
+      original,
+      inverse,
+      null,
+      basePath,
+      inversePatches,
+      pathAsArray,
+      arrayLengthAssignment
+    );
+  } else if (original.length < copy.length) {
+    // https://www.rfc-editor.org/rfc/rfc6902#appendix-A.4
+    // For performance, here we only generate an operation that replaces the length of the array,
+    // which is inconsistent with JSON Patch specification
+    if (arrayLengthAssignment) {
+      const _path = basePath.concat(['length']);
+      const path = escapePath(_path, pathAsArray);
+      inversePatches.push({
+        op: Operation.Replace,
+        path,
+        value: original.length,
+      });
+    } else {
+      for (let index = copy.length; original.length < index; index -= 1) {
+        const _path = basePath.concat([index - 1]);
+        const path = escapePath(_path, pathAsArray);
+        inversePatches.push({
+          op: Operation.Remove,
+          path,
+        });
+      }
+    }
+  }
+}
+
+function generatePatchesFromAssigned(
+  { original, copy, assignedMap }: ProxyDraft<Record<string, any>>,
+  basePath: any[],
+  patches: Patches,
+  inversePatches: Patches,
+  pathAsArray: boolean
+) {
+  assignedMap!.forEach((assignedValue, key) => {
+    const originalValue = get(original, key);
+    const value = cloneIfNeeded(get(copy, key));
+    const op = !assignedValue
+      ? Operation.Remove
+      : has(original, key)
+        ? Operation.Replace
+        : Operation.Add;
+    if (isEqual(originalValue, value) && op === Operation.Replace) return;
+    if (__DEV__) checkPathKey(getType(original), key, pathAsArray);
+    // A Map key can be an array, which stays one path segment.
+    const _path = basePath.concat([key]);
+    const path = escapePath(_path, pathAsArray);
+    patches.push(op === Operation.Remove ? { op, path } : { op, path, value });
+    inversePatches.push(
+      op === Operation.Add
+        ? { op: Operation.Remove, path }
+        : op === Operation.Remove
+          ? { op: Operation.Add, path, value: originalValue }
+          : { op: Operation.Replace, path, value: originalValue }
+    );
+  });
+}
+
+function generateSetPatches(
+  { original, copy }: ProxyDraft<Set<any>>,
+  basePath: any[],
+  patches: Patches,
+  inversePatches: Patches,
+  pathAsArray: boolean
+) {
+  let index = 0;
+  original.forEach((value: any) => {
+    if (!copy!.has(value)) {
+      const _path = basePath.concat([index]);
+      const path = escapePath(_path, pathAsArray);
+      patches.push({
+        op: Operation.Remove,
+        path,
+        value,
+      });
+      inversePatches.unshift({
+        op: Operation.Add,
+        path,
+        value,
+      });
+    }
+    index += 1;
+  });
+  index = 0;
+  copy!.forEach((value: any) => {
+    if (!original.has(value)) {
+      const _path = basePath.concat([index]);
+      const path = escapePath(_path, pathAsArray);
+      patches.push({
+        op: Operation.Add,
+        path,
+        value,
+      });
+      inversePatches.unshift({
+        op: Operation.Remove,
+        path,
+        value,
+      });
+    }
+    index += 1;
+  });
+}
+
+export function generatePatches(
+  proxyState: ProxyDraft,
+  basePath: any[],
+  patches: Patches,
+  inversePatches: Patches
+) {
+  const { pathAsArray = true } = proxyState.options.enablePatches;
+  switch (proxyState.type) {
+    case DraftType.Object:
+    case DraftType.Map:
+      return generatePatchesFromAssigned(
+        proxyState,
+        basePath,
+        patches,
+        inversePatches,
+        pathAsArray
+      );
+    case DraftType.Array:
+      return generateArrayPatches(
+        proxyState,
+        basePath,
+        patches,
+        inversePatches,
+        pathAsArray
+      );
+    case DraftType.Set:
+      return generateSetPatches(
+        proxyState,
+        basePath,
+        patches,
+        inversePatches,
+        pathAsArray
+      );
+  }
+}

package/node_modules/mutative/src/rawReturn.ts

@@ -0,0 +1,41 @@
+import { RAW_RETURN_SYMBOL } from './constant';
+import { die, ErrorCode } from './error';
+
+/**
+ * Use rawReturn() to wrap the return value to skip the draft check and thus improve performance.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { create, rawReturn } from 'mutative';
+ *
+ * const baseState = { foo: { bar: 'str' }, arr: [] };
+ * const state = create(
+ *   baseState,
+ *   (draft) => {
+ *     return rawReturn(baseState);
+ *   },
+ * );
+ * expect(state).toBe(baseState);
+ * ```
+ */
+export function rawReturn<T extends object | undefined>(value: T): T {
+  if (arguments.length === 0) {
+    die(ErrorCode.RawReturnWithoutValue);
+  }
+  if (arguments.length > 1) {
+    die(ErrorCode.RawReturnWithExtraArguments);
+  }
+  if (
+    __DEV__ &&
+    value !== undefined &&
+    (typeof value !== 'object' || value === null)
+  ) {
+    console.warn(
+      'rawReturn() must be called with an object(including plain object, arrays, Set, Map, etc.) or `undefined`, other types do not need to be returned via rawReturn().'
+    );
+  }
+  return {
+    [RAW_RETURN_SYMBOL]: [value],
+  } as never;
+}