@astrogate/sdk 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,189 @@
+import { DraftType, Finalities, Mark, ProxyDraft } from '../interface';
+import { dataTypes, PROXY_DRAFT } from '../constant';
+
+export function latest<T = any>(proxyDraft: ProxyDraft): T {
+  return proxyDraft.copy ?? proxyDraft.original;
+}
+
+// The drafts of a Set draft's items and the objects it added; see `src/set.ts`.
+export function getSetMap(target: ProxyDraft): Map<any, any> {
+  return target.setMap || (target.setMap = new Map());
+}
+
+// The value that an item of a Set draft stands for; `setMap` holds no
+// `undefined` value.
+export function setItemValue(target: ProxyDraft, item: any) {
+  const value = target.setMap && target.setMap.get(item);
+  return value === undefined ? item : value;
+}
+
+const setValues = Set.prototype.values;
+
+// The items of a Set in the order in which it holds them, also for a subclass
+// that iterates them otherwise, so that the positions in patch paths are those
+// that the draft iterates. A draft of an outer producer iterates them so
+// itself.
+export function iterateSet(set: Set<any>): IterableIterator<any> {
+  return isDraft(set) ? set.values() : setValues.call(set);
+}
+
+/**
+ * Check if the value is a draft
+ */
+export function isDraft(target: any) {
+  return !!getProxyDraft(target);
+}
+
+export function getProxyDraft<T extends any>(value: T): ProxyDraft | null {
+  if (typeof value !== 'object') return null;
+  return (value as { [PROXY_DRAFT]: any })?.[PROXY_DRAFT];
+}
+
+// Iterators retain draft state instead of reading through the proxy. Once
+// its scope has been revoked, use the proxy to throw the same native error.
+export function assertDraftActive(target: ProxyDraft) {
+  if (target.finalities.revoke.length === 0) getProxyDraft(target.proxy);
+}
+
+export function getValue<T extends object>(value: T): T {
+  const proxyDraft = getProxyDraft(value);
+  if (!proxyDraft) return value;
+  // A copy also exists once a child has merely been read; an unchanged draft
+  // still stands for its original, as every other finalization path decides.
+  return proxyDraft.operated ? proxyDraft.copy! : proxyDraft.original;
+}
+
+/**
+ * Check if a value is draftable
+ */
+export function isDraftable(value: any, options?: { mark?: Mark<any, any> }) {
+  if (!value || typeof value !== 'object') return false;
+  let markResult: any;
+  return (
+    Object.getPrototypeOf(value) === Object.prototype ||
+    Array.isArray(value) ||
+    value instanceof Map ||
+    value instanceof Set ||
+    (!!options?.mark &&
+      ((markResult = options.mark(value, dataTypes)) === dataTypes.immutable ||
+        typeof markResult === 'function'))
+  );
+}
+
+// A string path holds only strings, so a Map key of another type or a symbol
+// key would name a different key when the patch is applied. Development
+// builds check the keys of the patch paths they generate.
+export function checkPathKey(
+  type: DraftType,
+  key: unknown,
+  pathAsArray: boolean | undefined
+) {
+  if (
+    pathAsArray === false &&
+    typeof key !== 'string' &&
+    (type === DraftType.Map || typeof key === 'symbol')
+  ) {
+    throw new Error(
+      `Patches with string paths only support string Map keys and no symbol keys, got a key of type '${typeof key}'. Set 'pathAsArray' to true to keep keys of other types.`
+    );
+  }
+}
+
+export function getPath(
+  target: ProxyDraft,
+  path: any[] = []
+): (string | number | object)[] | null {
+  const parent = target.parent;
+  if (parent) {
+    const parentCopy = parent.copy;
+    let key: any = target.key;
+    if (parent.type === DraftType.Set) {
+      // Set items are keyed by their original value; paths use positions,
+      // which patches can follow only while the Set itself is unchanged.
+      // Once the recipe added or removed items, the Set's own patches carry
+      // every changed item by value, so patches under this path would be
+      // applied to whatever sits at the position in the base Set. An
+      // unchanged Set holds its items in their original order.
+      if (parent.assignedMap!.size > 0) return null;
+      // Counted without copying the Set, as each changed item searches it.
+      let index = 0;
+      for (const item of iterateSet(parent.original)) {
+        if (item === key) break;
+        index += 1;
+      }
+      key = index;
+    } else if (get(parentCopy, key) !== target.proxy) {
+      // The child left its key: it was moved, deleted or replaced, possibly
+      // by another draft of a shared object. The parent's patches carry its
+      // value wherever it is now, so patches under this path would be stale.
+      return null;
+    }
+    path.push(key);
+    const resolved = getPath(parent, path);
+    // Checked once the path resolves, as a stale path emits no patches.
+    if (__DEV__ && resolved) {
+      checkPathKey(parent.type, key, parent.options.enablePatches.pathAsArray);
+    }
+    return resolved;
+  }
+  // `target` is the root draft. Every level above found its child at its
+  // key, so the path resolves in the root's copy.
+  path.reverse();
+  return path;
+}
+
+export function getType(target: any) {
+  if (Array.isArray(target)) return DraftType.Array;
+  if (target instanceof Map) return DraftType.Map;
+  if (target instanceof Set) return DraftType.Set;
+  return DraftType.Object;
+}
+
+export function get(target: any, key: PropertyKey) {
+  return getType(target) === DraftType.Map ? target.get(key) : target[key];
+}
+
+export function set(target: any, key: PropertyKey, value: any) {
+  const type = getType(target);
+  if (type === DraftType.Map) {
+    target.set(key, value);
+  } else {
+    target[key] = value;
+  }
+}
+
+export function isEqual(x: any, y: any) {
+  if (x === y) {
+    return x !== 0 || 1 / x === 1 / y;
+  } else {
+    return x !== x && y !== y;
+  }
+}
+
+// Revokes every draft of a producer without reading any of them.
+export function revokeProxy(finalities: Finalities) {
+  const revoke = finalities.revoke;
+  while (revoke.length > 0) revoke.pop()!();
+}
+
+// handle JSON Pointer path with spec https://www.rfc-editor.org/rfc/rfc6901
+export function escapePath(path: string[], pathAsArray: boolean) {
+  return pathAsArray
+    ? path
+    : ['']
+        .concat(path)
+        .map((_item) => {
+          const item = `${_item}`;
+          if (item.indexOf('/') === -1 && item.indexOf('~') === -1) return item;
+          return item.replace(/~/g, '~0').replace(/\//g, '~1');
+        })
+        .join('/');
+}
+
+export function unescapePath(path: string | (string | number)[]) {
+  if (Array.isArray(path)) return path;
+  return path
+    .split('/')
+    .map((_item) => _item.replace(/~1/g, '/').replace(/~0/g, '~'))
+    .slice(1);
+}

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

@@ -0,0 +1,232 @@
+import { DraftType, Patches, ProxyDraft } from '../interface';
+import {
+  get,
+  getPath,
+  getProxyDraft,
+  getValue,
+  isDraft,
+  isDraftable,
+  isEqual,
+  iterateSet,
+  set,
+} from './draft';
+import { forEach } from './forEach';
+
+export function handleValue(
+  target: any,
+  handledSet: WeakSet<any>,
+  options?: ProxyDraft['options']
+) {
+  if (
+    isDraft(target) ||
+    !isDraftable(target, options) ||
+    handledSet.has(target) ||
+    Object.isFrozen(target)
+  )
+    return;
+  const isSet = target instanceof Set;
+  const setMap: Map<any, any> | undefined = isSet ? new Map() : undefined;
+  handledSet.add(target);
+  forEach(target, (key, value) => {
+    if (isDraft(value)) {
+      const proxyDraft = getProxyDraft(value)!;
+      // A draft where a child node has been changed, or assigned a value
+      const updatedValue =
+        proxyDraft.assignedMap?.size || proxyDraft.operated
+          ? proxyDraft.copy
+          : proxyDraft.original;
+      // final update value
+      set(isSet ? setMap! : target, key, updatedValue);
+    } else {
+      handleValue(value, handledSet, options);
+    }
+  });
+  if (setMap) {
+    const set = target as Set<any>;
+    const values = Array.from(set);
+    set.clear();
+    values.forEach((value) => {
+      set.add(setMap!.has(value) ? setMap!.get(value) : value);
+    });
+  }
+}
+
+export function finalizeAssigned(proxyDraft: ProxyDraft, key: PropertyKey) {
+  // handle the draftable assigned values， and the value is not a draft
+  const copy =
+    proxyDraft.type === DraftType.Set ? proxyDraft.setMap : proxyDraft.copy;
+  if (
+    proxyDraft.finalities.revoke.length > 1 &&
+    proxyDraft.assignedMap!.get(key) &&
+    copy
+  ) {
+    handleValue(
+      get(copy, key),
+      proxyDraft.finalities.handledSet,
+      proxyDraft.options
+    );
+  }
+}
+
+export type GeneratePatches = (
+  proxyState: ProxyDraft,
+  basePath: any[],
+  patches: Patches,
+  inversePatches: Patches
+) => void;
+
+// The copy of a Set draft holds its items in order, so only items that a draft
+// stands for may need their final value: the Set is rebuilt in order once one
+// of them differs from the item itself. The first rebuild keeps the items on
+// `setMap`. With `again`, only a Set rebuilt before is rebuilt, for a draft of
+// an outer producer that a nested producer's Set holds; other Sets may still
+// be changing, and are rebuilt when their own producer finalizes them.
+export function finalizeSetValue(target: ProxyDraft, again?: boolean) {
+  // Only Set drafts have `setMap`, and an unchanged draft stands for its
+  // original.
+  const setMap = target.setMap;
+  if (!setMap || !target.operated) return;
+  let items = setMap.items;
+  if (!items) {
+    if (again) return;
+    // Without added or deleted items, an item that the Set drafted changed,
+    // unless the recipe added and deleted a draft; rebuilding then changes
+    // nothing.
+    let differs = target.assignedMap!.size === 0;
+    if (!differs) {
+      for (const [item, value] of setMap) {
+        if (getValue(value) !== item) {
+          differs = true;
+          break;
+        }
+      }
+    }
+    if (!differs) return;
+    items = setMap.items = Array.from(iterateSet(target.copy));
+  }
+  const copy: Set<any> = target.copy;
+  copy.clear();
+  items.forEach((item) => {
+    const value = setMap.get(item);
+    copy.add(value === undefined ? item : getValue(value));
+  });
+}
+
+export function finalizePatches(
+  target: ProxyDraft,
+  generatePatches: GeneratePatches,
+  patches?: Patches,
+  inversePatches?: Patches
+) {
+  const shouldFinalize =
+    target.operated &&
+    ((target.arrayState !== null && target.arrayState.relocated) ||
+      (target.assignedMap !== undefined && target.assignedMap.size > 0)) &&
+    !target.finalized;
+  if (shouldFinalize) {
+    if (patches && inversePatches) {
+      const basePath = getPath(target);
+      if (basePath) {
+        generatePatches(target, basePath, patches, inversePatches);
+      }
+    }
+    target.finalized = true;
+  }
+}
+
+/**
+ * Finalize one draft node: write the final value back into the parent's copy,
+ * generate its patches and run callbacks registered for it, for example
+ * because it was assigned to another location.
+ */
+export function finalizeNode(
+  node: ProxyDraft,
+  generatePatches: GeneratePatches,
+  patches?: Patches,
+  inversePatches?: Patches
+) {
+  const parent = node.parent;
+  if (parent) {
+    const parentType = parent.type;
+    // if the parent is a Set draft, `setMap` is the real Set copies proxy mapping.
+    const copy = parentType === DraftType.Set ? parent.setMap : parent.copy;
+    const key = node.key!;
+    const isMapLike =
+      parentType === DraftType.Set || parentType === DraftType.Map;
+    const draft = isMapLike ? copy.get(key) : copy[key];
+    // Fast path: the node is still at its own key. Otherwise another draft
+    // may have been moved here, e.g. by `reverse()`, and is finalized instead.
+    const proxyDraft = draft === node.proxy ? node : getProxyDraft(draft);
+    // A draft that left its key reaches its new place as a value, through a
+    // callback or a value assigned there, so a Set finalizes its items here.
+    if (proxyDraft !== node) finalizeSetValue(node);
+    if (proxyDraft) {
+      // assign the updated value to the copy object
+      const updatedValue = proxyDraft.operated
+        ? proxyDraft.copy
+        : proxyDraft.original;
+      // A draft of another producer, which a recipe placed here, is
+      // finalized by that producer.
+      if (proxyDraft.finalities === node.finalities)
+        finalizeSetValue(proxyDraft);
+      finalizePatches(proxyDraft, generatePatches, patches, inversePatches);
+      // final update value
+      if (isMapLike) {
+        copy.set(key, updatedValue);
+      } else {
+        copy[key] = updatedValue;
+      }
+    }
+  } else {
+    // !case: handle the root draft
+    finalizeSetValue(node);
+    finalizePatches(node, generatePatches, patches, inversePatches);
+  }
+  // !case: handle the deleted key
+  const callbacks = node.callbacks;
+  if (callbacks) {
+    for (let index = 0; index < callbacks.length; index += 1) {
+      callbacks[index](patches, inversePatches);
+    }
+  }
+}
+
+export function markFinalization(target: ProxyDraft, key: any, value: any) {
+  const proxyDraft = getProxyDraft(value);
+  if (proxyDraft) {
+    // !case: assign the draft value
+    if (!proxyDraft.callbacks) {
+      proxyDraft.callbacks = [];
+    }
+    proxyDraft.callbacks.push(() => {
+      const copy = target.type === DraftType.Set ? target.setMap : target.copy;
+      if (isEqual(get(copy, key), value)) {
+        // The target generates its own patches once all drafts it holds have
+        // been finalized, so its patch values never need deep cloning.
+        const updatedValue = proxyDraft.operated
+          ? proxyDraft.copy
+          : proxyDraft.original;
+        // The drafts of a Set's own producer are done changing when it rebuilds
+        // the Set; a draft of another producer may change after that.
+        if (proxyDraft.finalities !== target.finalities)
+          finalizeSetValue(target, true);
+        // final update value
+        set(copy, key, updatedValue);
+      }
+    });
+    if (target.options.enableAutoFreeze) {
+      // !case: assign the draft value in cross draft tree
+      if (proxyDraft.finalities !== target.finalities) {
+        target.options.enableAutoFreeze = false;
+      }
+    }
+  } else if (isDraftable(value, target.options)) {
+    // !case: assign the non-draft value
+    target.finalities.draft.push(() => {
+      const copy = target.type === DraftType.Set ? target.setMap : target.copy;
+      if (isEqual(get(copy, key), value)) {
+        finalizeAssigned(target, key);
+      }
+    });
+  }
+}

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

@@ -0,0 +1,24 @@
+import { DraftType } from '../interface';
+import { getType } from './draft';
+
+export function forEach<T extends object>(
+  target: T,
+  iter: (key: string | number | symbol, value: any, source: T) => void
+) {
+  const type = getType(target);
+  if (type === DraftType.Object) {
+    Reflect.ownKeys(target).forEach((key) => {
+      iter(key, (target as any)[key], target);
+    });
+  } else if (type === DraftType.Array) {
+    let index = 0;
+    for (const entry of target as any[]) {
+      iter(index, entry, target);
+      index += 1;
+    }
+  } else {
+    (target as Map<any, any> | Set<any>).forEach((entry: any, index: any) =>
+      iter(index, entry, target)
+    );
+  }
+}

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

@@ -0,0 +1,7 @@
+export * from './copy';
+export * from './mark';
+export * from './deepFreeze';
+export * from './draft';
+export * from './proto';
+export * from './forEach';
+export * from './finalize';

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

@@ -0,0 +1,11 @@
+import { ProxyDraft } from '../interface';
+
+export function markChanged(proxyDraft: ProxyDraft) {
+  proxyDraft.assignedMap = proxyDraft.assignedMap ?? new Map();
+  if (!proxyDraft.operated) {
+    proxyDraft.operated = true;
+    if (proxyDraft.parent) {
+      markChanged(proxyDraft.parent);
+    }
+  }
+}

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

@@ -0,0 +1,34 @@
+import { dataTypes } from '../constant';
+
+const constructorString = Object.prototype.constructor.toString();
+// Whether a value is a plain object, an object without a prototype, or a plain
+// object of another realm, such as a same-origin iframe, whose constructor is
+// that realm's `Object`.
+const isSimpleObject = (value: unknown) => {
+  if (!value || typeof value !== 'object') return false;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype === null) {
+    return true;
+  }
+  const constructor =
+    Object.hasOwnProperty.call(prototype, 'constructor') &&
+    prototype.constructor;
+
+  if (constructor === Object) return true;
+
+  return (
+    typeof constructor === 'function' &&
+    Function.toString.call(constructor) === constructorString
+  );
+};
+
+/**
+ * A `mark` that drafts plain objects, objects without a prototype and plain
+ * objects of other realms, such as same-origin iframes.
+ */
+export const markSimpleObject = (value: unknown) => {
+  if (isSimpleObject(value)) {
+    return dataTypes.immutable;
+  }
+  return;
+};

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

@@ -0,0 +1,38 @@
+export function has(target: object, key: PropertyKey) {
+  return target instanceof Map
+    ? target.has(key)
+    : Object.prototype.hasOwnProperty.call(target, key);
+}
+
+export function getDescriptor(target: object, key: PropertyKey) {
+  if (key in target) {
+    let prototype = Reflect.getPrototypeOf(target);
+    while (prototype) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(prototype, key);
+      if (descriptor) return descriptor;
+      prototype = Reflect.getPrototypeOf(prototype);
+    }
+  }
+  return;
+}
+
+/**
+ * Whether `concat` and the array methods treat `array` like any array: no
+ * subclass, and no own `constructor` or `Symbol.isConcatSpreadable` that
+ * changes what `concat` creates.
+ */
+export function isPlainArray(array: any[]) {
+  return (
+    !Object.prototype.hasOwnProperty.call(array, 'constructor') &&
+    !Object.prototype.hasOwnProperty.call(array, Symbol.isConcatSpreadable) &&
+    Object.getPrototypeOf(array) === Array.prototype
+  );
+}
+
+export function isBaseSetInstance(obj: any) {
+  return Object.getPrototypeOf(obj) === Set.prototype;
+}
+
+export function isBaseMapInstance(obj: any) {
+  return Object.getPrototypeOf(obj) === Map.prototype;
+}

package/node_modules/uuid/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2010-2020 Robert Kieffer and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.