@highstate/designer 0.19.1 → 0.21.1

package/.output/server/node_modules/is-what/package.json

@@ -1,41 +1,35 @@
 {
   "name": "is-what",
-  "version": "4.1.16",
+  "version": "5.5.0",
   "description": "JS type check (TypeScript supported) functions like `isPlainObject() isArray()` etc. A simple & small integration.",
   "type": "module",
   "sideEffects": false,
-  "types": "./dist/index.d.ts",
-  "module": "./dist/index.js",
-  "main": "./dist/index.js",
   "exports": {
-    ".": {
-      "require": {
-        "types": "./dist/cjs/index.d.cts",
-        "default": "./dist/cjs/index.cjs"
-      },
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
-    }
+    ".": "./dist/index.js",
+    "./*": "./dist/*"
   },
-  "files": [
-    "dist"
-  ],
   "engines": {
-    "node": ">=12.13"
+    "node": ">=18"
   },
   "scripts": {
     "test": "vitest run",
-    "lint": "tsc --noEmit && eslint ./src --ext .ts",
-    "build": "rollup -c ./rollup.config.js",
+    "lint": "tsc --noEmit && oxlint",
+    "build": "del-cli dist && tsc",
     "build:docs": "typedoc",
-    "release": "npm run lint && del dist && npm run build && np"
+    "release": "npm run lint && npm run build && np --no-publish"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/mesqueeb/is-what.git"
+  "devDependencies": {
+    "@cycraft/eslint": "^0.4.4",
+    "@cycraft/tsconfig": "^0.1.2",
+    "del-cli": "^7.0.0",
+    "np": "^10.2.0",
+    "oxlint": "^1.16.0",
+    "typedoc": "^0.28.13",
+    "vitest": "^3.2.4"
   },
+  "files": [
+    "dist"
+  ],
   "keywords": [
     "javascript",
     "typescript",
@@ -57,72 +51,13 @@
     "is-plain-obj",
     "is-plain-object"
   ],
-  "author": "Luca Ban - Mesqueeb",
+  "author": "Luca Ban - Mesqueeb (https://cycraft.co)",
   "funding": "https://github.com/sponsors/mesqueeb",
   "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/mesqueeb/is-what/issues"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mesqueeb/is-what.git"
   },
   "homepage": "https://github.com/mesqueeb/is-what#readme",
-  "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^5.62.0",
-    "@typescript-eslint/parser": "^5.62.0",
-    "del-cli": "^5.1.0",
-    "eslint-config-prettier": "^8.10.0",
-    "eslint-plugin-tree-shaking": "^1.10.1",
-    "eslint": "^8.52.0",
-    "np": "^8.0.4",
-    "prettier-plugin-jsdoc": "^0.4.2",
-    "prettier": "^2.8.8",
-    "rollup-plugin-dts": "^5.3.1",
-    "rollup-plugin-esbuild": "^5.0.0",
-    "rollup": "^3.29.4",
-    "typedoc": "^0.25.2",
-    "typescript": "^5.2.2",
-    "vitest": "^0.34.6"
-  },
-  "np": {
-    "branch": "production",
-    "publish": false,
-    "yarn": false
-  },
-  "eslintConfig": {
-    "ignorePatterns": [
-      "node_modules",
-      "dist",
-      "scripts",
-      "test"
-    ],
-    "root": true,
-    "parser": "@typescript-eslint/parser",
-    "plugins": [
-      "@typescript-eslint",
-      "tree-shaking"
-    ],
-    "extends": [
-      "eslint:recommended",
-      "plugin:@typescript-eslint/eslint-recommended",
-      "plugin:@typescript-eslint/recommended",
-      "prettier"
-    ],
-    "rules": {
-      "@typescript-eslint/no-empty-function": "off",
-      "@typescript-eslint/no-explicit-any": "off",
-      "@typescript-eslint/ban-ts-ignore": "off",
-      "tree-shaking/no-side-effects-in-initialization": "error",
-      "@typescript-eslint/ban-ts-comment": "off"
-    }
-  },
-  "prettier": {
-    "printWidth": 100,
-    "tabWidth": 2,
-    "singleQuote": true,
-    "trailingComma": "es5",
-    "semi": false,
-    "bracketSpacing": true,
-    "quoteProps": "consistent",
-    "plugins": [
-      "prettier-plugin-jsdoc"
-    ]
-  }
+  "bugs": "https://github.com/mesqueeb/is-what/issues"
 }

package/.output/server/node_modules/superjson/dist/index.js

@@ -3,7 +3,7 @@ import { Registry } from './registry.js';
 import { CustomTransformerRegistry, } from './custom-transformer-registry.js';
 import { applyReferentialEqualityAnnotations, applyValueAnnotations, generateReferentialEqualityAnnotations, walker, } from './plainer.js';
 import { copy } from 'copy-anything';
-export default class SuperJSON {
+class SuperJSON {
     /**
      * @param dedupeReferentialEqualities  If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
      */
@@ -33,16 +33,18 @@ export default class SuperJSON {
                 referentialEqualities: equalityAnnotations,
             };
         }
+        if (res.meta)
+            res.meta.v = 1;
         return res;
     }
-    deserialize(payload) {
+    deserialize(payload, options) {
         const { json, meta } = payload;
-        let result = copy(json);
+        let result = options?.inPlace ? json : copy(json);
         if (meta?.values) {
-            result = applyValueAnnotations(result, meta.values, this);
+            result = applyValueAnnotations(result, meta.values, meta.v ?? 0, this);
         }
         if (meta?.referentialEqualities) {
-            result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities);
+            result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities, meta.v ?? 0);
         }
         return result;
     }
@@ -50,7 +52,7 @@ export default class SuperJSON {
         return JSON.stringify(this.serialize(object));
     }
     parse(string) {
-        return this.deserialize(JSON.parse(string));
+        return this.deserialize(JSON.parse(string), { inPlace: true });
     }
     registerClass(v, options) {
         this.classRegistry.register(v, options);
@@ -77,6 +79,7 @@ SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON
 SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);
 SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
 SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
+export default SuperJSON;
 export { SuperJSON };
 export const serialize = SuperJSON.serialize;
 export const deserialize = SuperJSON.deserialize;

package/.output/server/node_modules/superjson/dist/pathstringifier.js

@@ -1,13 +1,24 @@
-export const escapeKey = (key) => key.replace(/\./g, '\\.');
+export const escapeKey = (key) => key.replace(/\\/g, '\\\\').replace(/\./g, '\\.');
 export const stringifyPath = (path) => path
     .map(String)
     .map(escapeKey)
     .join('.');
-export const parsePath = (string) => {
+export const parsePath = (string, legacyPaths) => {
     const result = [];
     let segment = '';
     for (let i = 0; i < string.length; i++) {
         let char = string.charAt(i);
+        if (!legacyPaths && char === '\\') {
+            const escaped = string.charAt(i + 1);
+            if (escaped === '\\') {
+                segment += '\\';
+                i++;
+                continue;
+            }
+            else if (escaped !== '.') {
+                throw Error('invalid path');
+            }
+        }
         const isEscapedDot = char === '\\' && string.charAt(i + 1) === '.';
         if (isEscapedDot) {
             segment += '.';

package/.output/server/node_modules/superjson/dist/plainer.js

@@ -1,42 +1,53 @@
-import { isArray, isEmptyObject, isMap, isPlainObject, isPrimitive, isSet, } from './is.js';
+import { isArray, isEmptyObject, isError, isMap, isPlainObject, isPrimitive, isSet, } from './is.js';
 import { escapeKey, stringifyPath } from './pathstringifier.js';
 import { isInstanceOfRegisteredClass, transformValue, untransformValue, } from './transformer.js';
 import { includes, forEach } from './util.js';
 import { parsePath } from './pathstringifier.js';
 import { getDeep, setDeep } from './accessDeep.js';
-function traverse(tree, walker, origin = []) {
+const enableLegacyPaths = (version) => version < 1;
+function traverse(tree, walker, version, origin = []) {
     if (!tree) {
         return;
     }
+    const legacyPaths = enableLegacyPaths(version);
     if (!isArray(tree)) {
-        forEach(tree, (subtree, key) => traverse(subtree, walker, [...origin, ...parsePath(key)]));
+        forEach(tree, (subtree, key) => traverse(subtree, walker, version, [
+            ...origin,
+            ...parsePath(key, legacyPaths),
+        ]));
         return;
     }
     const [nodeValue, children] = tree;
     if (children) {
         forEach(children, (child, key) => {
-            traverse(child, walker, [...origin, ...parsePath(key)]);
+            traverse(child, walker, version, [
+                ...origin,
+                ...parsePath(key, legacyPaths),
+            ]);
         });
     }
     walker(nodeValue, origin);
 }
-export function applyValueAnnotations(plain, annotations, superJson) {
+export function applyValueAnnotations(plain, annotations, version, superJson) {
     traverse(annotations, (type, path) => {
         plain = setDeep(plain, path, v => untransformValue(v, type, superJson));
-    });
+    }, version);
     return plain;
 }
-export function applyReferentialEqualityAnnotations(plain, annotations) {
+export function applyReferentialEqualityAnnotations(plain, annotations, version) {
+    const legacyPaths = enableLegacyPaths(version);
     function apply(identicalPaths, path) {
-        const object = getDeep(plain, parsePath(path));
-        identicalPaths.map(parsePath).forEach(identicalObjectPath => {
+        const object = getDeep(plain, parsePath(path, legacyPaths));
+        identicalPaths
+            .map(path => parsePath(path, legacyPaths))
+            .forEach(identicalObjectPath => {
             plain = setDeep(plain, identicalObjectPath, () => object);
         });
     }
     if (isArray(annotations)) {
         const [root, other] = annotations;
         root.forEach(identicalPath => {
-            plain = setDeep(plain, parsePath(identicalPath), () => plain);
+            plain = setDeep(plain, parsePath(identicalPath, legacyPaths), () => plain);
         });
         if (other) {
             forEach(other, apply);
@@ -51,6 +62,7 @@ const isDeep = (object, superJson) => isPlainObject(object) ||
     isArray(object) ||
     isMap(object) ||
     isSet(object) ||
+    isError(object) ||
     isInstanceOfRegisteredClass(object, superJson);
 function addIdentity(object, path, identities) {
     const existingSet = identities.get(object);
@@ -144,7 +156,7 @@ export const walker = (object, identities, superJson, dedupe, path = [], objects
         const recursiveResult = walker(value, identities, superJson, dedupe, [...path, index], [...objectsInThisPath, object], seenObjects);
         transformedValue[index] = recursiveResult.transformedValue;
         if (isArray(recursiveResult.annotations)) {
-            innerAnnotations[index] = recursiveResult.annotations;
+            innerAnnotations[escapeKey(index)] = recursiveResult.annotations;
         }
         else if (isPlainObject(recursiveResult.annotations)) {
             forEach(recursiveResult.annotations, (tree, key) => {

package/.output/server/node_modules/superjson/dist/transformer.js

@@ -23,12 +23,15 @@ const simpleRules = [
             name: v.name,
             message: v.message,
         };
+        if ('cause' in v) {
+            baseError.cause = v.cause;
+        }
         superJson.allowedErrorProps.forEach(prop => {
             baseError[prop] = v[prop];
         });
         return baseError;
     }, (v, superJson) => {
-        const e = new Error(v.message);
+        const e = new Error(v.message, { cause: v.cause });
         e.name = v.name;
         e.stack = v.stack;
         superJson.allowedErrorProps.forEach(prop => {

package/.output/server/node_modules/superjson/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.2.2",
+  "version": "2.2.6",
   "license": "MIT",
   "type": "module",
   "typings": "dist/index.d.ts",
@@ -16,16 +16,7 @@
   "scripts": {
     "build": "tsc",
     "test": "vitest run",
-    "lint": "tsdx lint",
-    "prepack": "yarn build",
-    "prepare": "husky install",
-    "publish-please": "publish-please",
-    "prepublishOnly": "publish-please guard"
-  },
-  "importSort": {
-    ".ts": {
-      "style": "module"
-    }
+    "prepack": "npm run build"
   },
   "prettier": {
     "printWidth": 80,
@@ -58,22 +49,15 @@
   "devDependencies": {
     "@types/debug": "^4.1.5",
     "@types/mongodb": "^3.6.12",
-    "@types/node": "^18.7.18",
+    "@types/node": "^24.10.1",
     "benchmark": "^2.1.4",
     "decimal.js": "^10.3.1",
-    "eslint-plugin-es5": "^1.5.0",
-    "husky": "^6.0.0",
     "mongodb": "^3.6.6",
-    "publish-please": "^5.5.2",
     "tsdx": "^0.14.1",
-    "typescript": "^4.2.4",
+    "typescript": "^5.9.3",
     "vitest": "^0.34.6"
   },
   "dependencies": {
-    "copy-anything": "^3.0.2"
-  },
-  "resolutions": {
-    "**/@typescript-eslint/eslint-plugin": "^4.11.1",
-    "**/@typescript-eslint/parser": "^4.11.1"
+    "copy-anything": "^4"
   }
 }