@astrogate/sdk 0.0.0-stage → 0.1.0

package/node_modules/mutative/package.json

@@ -0,0 +1,142 @@
+{
+  "name": "mutative",
+  "version": "2.0.1",
+  "description": "A JavaScript library for efficient immutable updates",
+  "main": "dist/index.js",
+  "module": "dist/mutative.esm.js",
+  "umd:main": "dist/mutative.umd.production.min.js",
+  "unpkg": "dist/mutative.umd.production.min.js",
+  "jsdelivr": "dist/mutative.umd.production.min.js",
+  "jsnext:main": "dist/mutative.esm.js",
+  "react-native": "dist/mutative.esm.js",
+  "source": "src/index.ts",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "node": "./dist/index.mjs",
+        "default": "./dist/mutative.esm.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./*": "./*"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "test:package": "node scripts/check-package.mjs",
+    "test:build-watch": "node scripts/check-build-watch.mjs",
+    "test:api-docs": "node scripts/check-api-docs.mjs",
+    "type-check": "tsc --noEmit && tsc --noEmit -p test",
+    "lint": "oxlint",
+    "clean": "rimraf dist",
+    "test:coverage": "vitest run --coverage && coveralls < coverage/lcov.info",
+    "benchmark:immer": "pnpm build && pnpm benchmark:immer:build && node perf-testing/run-benchmarks.mjs",
+    "benchmark:immer:build": "node perf-testing/build.mjs",
+    "benchmark:immer:check": "pnpm build && pnpm benchmark:immer:build && node --expose-gc --enable-source-maps perf-testing/dist/immutability-benchmarks.mjs --check --patches both",
+    "benchmark:memory": "pnpm build && pnpm benchmark:immer:build && node perf-testing/run-memory.mjs",
+    "benchmark:ci": "pnpm build && node perf-testing/ci.mjs",
+    "test:benchmarks": "node --expose-gc --test perf-testing/*.test.mjs",
+    "profile:immer": "pnpm build && pnpm benchmark:immer:build && node --expose-gc --enable-source-maps perf-testing/dist/immutability-profiling.mjs",
+    "profile:immer:analyze": "node perf-testing/read-cpuprofile.mjs",
+    "build": "pnpm run clean && tsdown && tsc --noEmit false --emitDeclarationOnly --outDir dist && node scripts/write-package-entries.mjs",
+    "build:analyze": "ANALYZE=true pnpm build",
+    "build:doc": "rimraf docs && typedoc",
+    "commit": "git-cz",
+    "size": "size-limit && pnpm size:compare",
+    "size:compare": "node scripts/check-build-size.mjs",
+    "analyze": "size-limit --why",
+    "format": "oxfmt \"src/**/*.ts\" \"test/**/*.ts\"",
+    "publish:docs": "pnpm run clean && cd website && pnpm run deploy",
+    "start:docs": "cd website && pnpm run dev"
+  },
+  "size-limit": [
+    {
+      "name": "production CJS, all exports",
+      "path": "dist/mutative.cjs.production.min.js",
+      "import": "*",
+      "limit": "9.1 KB"
+    },
+    {
+      "name": "ESM, create",
+      "path": "dist/mutative.esm.mjs",
+      "import": "{ create }",
+      "limit": "8.1 KB"
+    },
+    {
+      "name": "ESM, all exports",
+      "path": "dist/mutative.esm.mjs",
+      "import": "*",
+      "limit": "9.0 KB"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unadlib/mutative.git"
+  },
+  "author": "unadlib",
+  "keywords": [
+    "immutable",
+    "mutable",
+    "copy-on-write",
+    "mutative",
+    "immutability",
+    "mutation"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.0"
+  },
+  "packageManager": "pnpm@12.6.0",
+  "bugs": {
+    "url": "https://github.com/unadlib/mutative/issues"
+  },
+  "homepage": "https://mutative.js.org/",
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
+    "@size-limit/esbuild": "^11.1.6",
+    "@size-limit/esbuild-why": "^11.2.0",
+    "@size-limit/preset-small-lib": "^11.1.6",
+    "@size-limit/webpack": "^11.1.6",
+    "@size-limit/webpack-why": "^11.1.6",
+    "@types/node": "^24.0.13",
+    "@vitest/coverage-v8": "^5.0.1",
+    "commitizen": "^4.3.1",
+    "coveralls": "^3.1.1",
+    "deep-freeze": "^0.0.1",
+    "esbuild": "0.24.0",
+    "fast-json-patch": "^3.1.1",
+    "immer": "11.1.18",
+    "lodash": "^4.17.21",
+    "mitata": "1.0.34",
+    "mutative-v1": "npm:mutative@1.3.0",
+    "oxfmt": "^0.70.0",
+    "oxlint": "^1.85.0",
+    "publint": "^0.3.24",
+    "redux": "^5.0.1",
+    "rimraf": "^6.0.1",
+    "size-limit": "^11.1.6",
+    "terser": "5.34.1",
+    "tsdown": "^0.23.0",
+    "tslib": "^2.8.1",
+    "typedoc": "^0.28.12",
+    "typedoc-plugin-markdown": "^4.8.1",
+    "typescript": "^5.8.3",
+    "typescript-5.0": "npm:typescript@5.0.4",
+    "vite-bundle-analyzer": "^1.3.2",
+    "vitest": "^5.0.1",
+    "yargs": "^17.7.2"
+  },
+  "config": {
+    "commitizen": {
+      "path": "cz-conventional-changelog"
+    }
+  }
+}

package/node_modules/mutative/src/apply.ts

@@ -0,0 +1,239 @@
+import { Operation, DraftType } from './interface';
+import type {
+  Draft,
+  Patches,
+  ApplyImmutableOptions,
+  ApplyMutableOptions,
+  ApplyOptions,
+  ApplyResult,
+} from './interface';
+import {
+  deepClone,
+  getProxyDraft,
+  getType,
+  has,
+  isDraft,
+  unescapePath,
+} from './utils';
+import { create } from './create';
+import { die, ErrorCode } from './error';
+
+// A draft knows its type, which `getType` would find only through the traps of
+// its proxy. Any other value is typed as before, also a proxy of the
+// application that rejects reading the symbol of drafts.
+function getPatchTargetType(value: any) {
+  try {
+    const proxyDraft = getProxyDraft(value);
+    if (proxyDraft) return proxyDraft.type;
+  } catch {
+    // Not a draft.
+  }
+  return getType(value);
+}
+
+function normalizePatchKey(key: any) {
+  // Let JavaScript perform ToPropertyKey once, including a Symbol result.
+  // Primitive keys cannot disguise a reserved name and need no conversion here.
+  return typeof key === 'object' || typeof key === 'function'
+    ? Reflect.ownKeys({ [key]: 0 })[0]
+    : key;
+}
+
+/**
+ * `apply(state, patches)` to apply patches to state
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { create, apply } from 'mutative';
+ *
+ * const baseState = { foo: { bar: 'str' }, arr: [] };
+ * const [state, patches] = create(
+ *   baseState,
+ *   (draft) => {
+ *     draft.foo.bar = 'str2';
+ *   },
+ *   { enablePatches: true }
+ * );
+ * expect(state).toEqual({ foo: { bar: 'str2' }, arr: [] });
+ * expect(patches).toEqual([{ op: 'replace', path: ['foo', 'bar'], value: 'str2' }]);
+ * expect(state).toEqual(apply(baseState, patches));
+ * ```
+ */
+export function apply<
+  T extends object,
+  F extends boolean = false,
+  _A extends ApplyOptions<boolean> | undefined = ApplyImmutableOptions<F>,
+>(
+  state: T,
+  patches: Patches,
+  applyOptions?: undefined
+): ApplyResult<T, F, undefined>;
+export function apply<
+  T extends object,
+  F extends boolean = false,
+  A extends ApplyOptions<boolean> | undefined = ApplyImmutableOptions<F>,
+>(state: T, patches: Patches, applyOptions: A): ApplyResult<T, F, A>;
+// A wrapper may supply A explicitly while forwarding optional options. Keep
+// undefined in its result, but prefer the exact overload above when present.
+export function apply<
+  T extends object,
+  F extends boolean = false,
+  A extends ApplyOptions<boolean> | undefined = ApplyImmutableOptions<F>,
+>(
+  state: T,
+  patches: Patches,
+  applyOptions?: A
+): ApplyResult<T, F, A | undefined>;
+// With an explicit T, A takes its default instead of being inferred. Keep
+// mutable options available without making calls with no options return void.
+export function apply<T extends object, F extends boolean = false>(
+  state: T,
+  patches: Patches,
+  applyOptions: { mutable: true }
+): ApplyResult<T, F, { mutable: true }>;
+export function apply<T extends object, F extends boolean = false>(
+  state: T,
+  patches: Patches,
+  applyOptions: ApplyMutableOptions | undefined
+): ApplyResult<T, F, ApplyMutableOptions | undefined>;
+export function apply<
+  T extends object,
+  F extends boolean = false,
+  A extends ApplyOptions<boolean> | undefined = ApplyImmutableOptions<F>,
+>(state: T, patches: Patches, applyOptions?: A): ApplyResult<T, F, A> {
+  const mutable = (applyOptions as ApplyMutableOptions)?.mutable;
+  let i: number;
+  for (i = patches.length - 1; i >= 0; i -= 1) {
+    const { value, op, path } = patches[i];
+    if (
+      (!path.length && op === Operation.Replace) ||
+      (path === '' && op === Operation.Add)
+    ) {
+      // A mutable application changes the state in place and returns nothing,
+      // so it cannot replace the state with another value.
+      if (mutable && value !== state) die(ErrorCode.ReplaceMutableRoot);
+      state = value;
+      break;
+    }
+  }
+  if (i > -1) {
+    patches = patches.slice(i + 1);
+  }
+  // The objects that a mutable application changes in place are not drafts.
+  const getTargetType = mutable ? getType : getPatchTargetType;
+  const mutate = (draft: Draft<T> | T) => {
+    patches.forEach((patch) => {
+      const { path: _path, op } = patch;
+      const path = unescapePath(_path);
+      let base: any = draft;
+      for (let index = 0; index < path.length - 1; index += 1) {
+        const parentType = getTargetType(base);
+        let key = path[index];
+        // Map keys and Set positions retain their native identity/semantics.
+        if (parentType <= DraftType.Array) {
+          key = normalizePatchKey(key);
+          if (
+            key === '__proto__' ||
+            key === 'constructor' ||
+            (typeof base === 'function' && key === 'prototype')
+          ) {
+            die(ErrorCode.ReservedPatchAttribute);
+          }
+        }
+        if (parentType === DraftType.Set) {
+          // A Set item is found at its index in the array of the Set's items,
+          // so that no other key, such as `__proto__`, reads a property that
+          // the array inherits. No number names such a property. The key is
+          // converted once, so that the check and the read use the same key.
+          key = normalizePatchKey(key);
+          base = Array.from(base);
+          if (typeof key !== 'number' && !has(base, key))
+            die(ErrorCode.CannotApplyPatch, path);
+        }
+        base = parentType === DraftType.Map ? base.get(key) : base[key];
+        if (typeof base !== 'object') {
+          die(ErrorCode.CannotApplyPatch, path);
+        }
+      }
+
+      const type = getTargetType(base);
+      // ensure the original patch is not modified.
+      const value = deepClone(patch.value);
+      let key = path[path.length - 1];
+      // The last segment is assigned, and an assignment to `__proto__` sets
+      // the prototype of an object or array instead of a property.
+      if (type <= DraftType.Array) {
+        // Array add/remove use splice indices, which follow ToNumber instead.
+        if (type === DraftType.Object || op === Operation.Replace) {
+          key = normalizePatchKey(key);
+        }
+        if (key === '__proto__') die(ErrorCode.ReservedPatchAttribute);
+      }
+      switch (op) {
+        case Operation.Replace:
+          switch (type) {
+            case DraftType.Map:
+              return base.set(key, value);
+            case DraftType.Set:
+              return die(ErrorCode.ReplacePatchOnSet);
+            default:
+              return (base[key] = value);
+          }
+        case Operation.Add:
+          switch (type) {
+            case DraftType.Array:
+              // If the "-" character is used to
+              // index the end of the array (see [RFC6901](https://datatracker.ietf.org/doc/html/rfc6902)),
+              // this has the effect of appending the value to the array.
+              return key === '-'
+                ? base.push(value)
+                : base.splice(key as number, 0, value);
+            case DraftType.Map:
+              return base.set(key, value);
+            case DraftType.Set:
+              return base.add(value);
+            default:
+              return (base[key] = value);
+          }
+        case Operation.Remove:
+          switch (type) {
+            case DraftType.Array:
+              return base.splice(key as number, 1);
+            case DraftType.Map:
+              return base.delete(key);
+            case DraftType.Set:
+              return base.delete(patch.value);
+            default:
+              return delete base[key];
+          }
+        default:
+          die(ErrorCode.UnsupportedPatchOperation, op);
+      }
+    });
+  };
+  if (mutable) {
+    if (__DEV__) {
+      if (
+        Object.keys(applyOptions!).filter((key) => key !== 'mutable').length
+      ) {
+        console.warn(
+          'The "mutable" option is not allowed to be used with other options.'
+        );
+      }
+    }
+    mutate(state);
+    return undefined as ApplyResult<T, F, A>;
+  }
+  if (isDraft(state)) {
+    if (applyOptions !== undefined) {
+      die(ErrorCode.ApplyOptionsToDraft);
+    }
+    mutate(state as Draft<T>);
+    return state as ApplyResult<T, F, A>;
+  }
+  return create<T, F>(state, mutate, {
+    ...(applyOptions as ApplyOptions<F>),
+    enablePatches: false,
+  }) as T as ApplyResult<T, F, A>;
+}