@highstate/designer 0.9.16 → 0.9.19

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

@@ -0,0 +1,197 @@
+import { isBigint, isDate, isInfinite, isMap, isNaNValue, isRegExp, isSet, isUndefined, isSymbol, isArray, isError, isTypedArray, isURL, } from './is.js';
+import { findArr } from './util.js';
+function simpleTransformation(isApplicable, annotation, transform, untransform) {
+    return {
+        isApplicable,
+        annotation,
+        transform,
+        untransform,
+    };
+}
+const simpleRules = [
+    simpleTransformation(isUndefined, 'undefined', () => null, () => undefined),
+    simpleTransformation(isBigint, 'bigint', v => v.toString(), v => {
+        if (typeof BigInt !== 'undefined') {
+            return BigInt(v);
+        }
+        console.error('Please add a BigInt polyfill.');
+        return v;
+    }),
+    simpleTransformation(isDate, 'Date', v => v.toISOString(), v => new Date(v)),
+    simpleTransformation(isError, 'Error', (v, superJson) => {
+        const baseError = {
+            name: v.name,
+            message: v.message,
+        };
+        superJson.allowedErrorProps.forEach(prop => {
+            baseError[prop] = v[prop];
+        });
+        return baseError;
+    }, (v, superJson) => {
+        const e = new Error(v.message);
+        e.name = v.name;
+        e.stack = v.stack;
+        superJson.allowedErrorProps.forEach(prop => {
+            e[prop] = v[prop];
+        });
+        return e;
+    }),
+    simpleTransformation(isRegExp, 'regexp', v => '' + v, regex => {
+        const body = regex.slice(1, regex.lastIndexOf('/'));
+        const flags = regex.slice(regex.lastIndexOf('/') + 1);
+        return new RegExp(body, flags);
+    }),
+    simpleTransformation(isSet, 'set', 
+    // (sets only exist in es6+)
+    // eslint-disable-next-line es5/no-es6-methods
+    v => [...v.values()], v => new Set(v)),
+    simpleTransformation(isMap, 'map', v => [...v.entries()], v => new Map(v)),
+    simpleTransformation((v) => isNaNValue(v) || isInfinite(v), 'number', v => {
+        if (isNaNValue(v)) {
+            return 'NaN';
+        }
+        if (v > 0) {
+            return 'Infinity';
+        }
+        else {
+            return '-Infinity';
+        }
+    }, Number),
+    simpleTransformation((v) => v === 0 && 1 / v === -Infinity, 'number', () => {
+        return '-0';
+    }, Number),
+    simpleTransformation(isURL, 'URL', v => v.toString(), v => new URL(v)),
+];
+function compositeTransformation(isApplicable, annotation, transform, untransform) {
+    return {
+        isApplicable,
+        annotation,
+        transform,
+        untransform,
+    };
+}
+const symbolRule = compositeTransformation((s, superJson) => {
+    if (isSymbol(s)) {
+        const isRegistered = !!superJson.symbolRegistry.getIdentifier(s);
+        return isRegistered;
+    }
+    return false;
+}, (s, superJson) => {
+    const identifier = superJson.symbolRegistry.getIdentifier(s);
+    return ['symbol', identifier];
+}, v => v.description, (_, a, superJson) => {
+    const value = superJson.symbolRegistry.getValue(a[1]);
+    if (!value) {
+        throw new Error('Trying to deserialize unknown symbol');
+    }
+    return value;
+});
+const constructorToName = [
+    Int8Array,
+    Uint8Array,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float32Array,
+    Float64Array,
+    Uint8ClampedArray,
+].reduce((obj, ctor) => {
+    obj[ctor.name] = ctor;
+    return obj;
+}, {});
+const typedArrayRule = compositeTransformation(isTypedArray, v => ['typed-array', v.constructor.name], v => [...v], (v, a) => {
+    const ctor = constructorToName[a[1]];
+    if (!ctor) {
+        throw new Error('Trying to deserialize unknown typed array');
+    }
+    return new ctor(v);
+});
+export function isInstanceOfRegisteredClass(potentialClass, superJson) {
+    if (potentialClass?.constructor) {
+        const isRegistered = !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
+        return isRegistered;
+    }
+    return false;
+}
+const classRule = compositeTransformation(isInstanceOfRegisteredClass, (clazz, superJson) => {
+    const identifier = superJson.classRegistry.getIdentifier(clazz.constructor);
+    return ['class', identifier];
+}, (clazz, superJson) => {
+    const allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
+    if (!allowedProps) {
+        return { ...clazz };
+    }
+    const result = {};
+    allowedProps.forEach(prop => {
+        result[prop] = clazz[prop];
+    });
+    return result;
+}, (v, a, superJson) => {
+    const clazz = superJson.classRegistry.getValue(a[1]);
+    if (!clazz) {
+        throw new Error(`Trying to deserialize unknown class '${a[1]}' - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564`);
+    }
+    return Object.assign(Object.create(clazz.prototype), v);
+});
+const customRule = compositeTransformation((value, superJson) => {
+    return !!superJson.customTransformerRegistry.findApplicable(value);
+}, (value, superJson) => {
+    const transformer = superJson.customTransformerRegistry.findApplicable(value);
+    return ['custom', transformer.name];
+}, (value, superJson) => {
+    const transformer = superJson.customTransformerRegistry.findApplicable(value);
+    return transformer.serialize(value);
+}, (v, a, superJson) => {
+    const transformer = superJson.customTransformerRegistry.findByName(a[1]);
+    if (!transformer) {
+        throw new Error('Trying to deserialize unknown custom value');
+    }
+    return transformer.deserialize(v);
+});
+const compositeRules = [classRule, symbolRule, customRule, typedArrayRule];
+export const transformValue = (value, superJson) => {
+    const applicableCompositeRule = findArr(compositeRules, rule => rule.isApplicable(value, superJson));
+    if (applicableCompositeRule) {
+        return {
+            value: applicableCompositeRule.transform(value, superJson),
+            type: applicableCompositeRule.annotation(value, superJson),
+        };
+    }
+    const applicableSimpleRule = findArr(simpleRules, rule => rule.isApplicable(value, superJson));
+    if (applicableSimpleRule) {
+        return {
+            value: applicableSimpleRule.transform(value, superJson),
+            type: applicableSimpleRule.annotation,
+        };
+    }
+    return undefined;
+};
+const simpleRulesByAnnotation = {};
+simpleRules.forEach(rule => {
+    simpleRulesByAnnotation[rule.annotation] = rule;
+});
+export const untransformValue = (json, type, superJson) => {
+    if (isArray(type)) {
+        switch (type[0]) {
+            case 'symbol':
+                return symbolRule.untransform(json, type, superJson);
+            case 'class':
+                return classRule.untransform(json, type, superJson);
+            case 'custom':
+                return customRule.untransform(json, type, superJson);
+            case 'typed-array':
+                return typedArrayRule.untransform(json, type, superJson);
+            default:
+                throw new Error('Unknown transformation: ' + type);
+        }
+    }
+    else {
+        const transformation = simpleRulesByAnnotation[type];
+        if (!transformation) {
+            throw new Error('Unknown transformation: ' + type);
+        }
+        return transformation.untransform(json, superJson);
+    }
+};
+//# sourceMappingURL=transformer.js.map

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

@@ -0,0 +1,45 @@
+function valuesOfObj(record) {
+    if ('values' in Object) {
+        // eslint-disable-next-line es5/no-es6-methods
+        return Object.values(record);
+    }
+    const values = [];
+    // eslint-disable-next-line no-restricted-syntax
+    for (const key in record) {
+        if (record.hasOwnProperty(key)) {
+            values.push(record[key]);
+        }
+    }
+    return values;
+}
+export function find(record, predicate) {
+    const values = valuesOfObj(record);
+    if ('find' in values) {
+        // eslint-disable-next-line es5/no-es6-methods
+        return values.find(predicate);
+    }
+    const valuesNotNever = values;
+    for (let i = 0; i < valuesNotNever.length; i++) {
+        const value = valuesNotNever[i];
+        if (predicate(value)) {
+            return value;
+        }
+    }
+    return undefined;
+}
+export function forEach(record, run) {
+    Object.entries(record).forEach(([key, value]) => run(value, key));
+}
+export function includes(arr, value) {
+    return arr.indexOf(value) !== -1;
+}
+export function findArr(record, predicate) {
+    for (let i = 0; i < record.length; i++) {
+        const value = record[i];
+        if (predicate(value)) {
+            return value;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=util.js.map

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

@@ -0,0 +1,79 @@
+{
+  "version": "2.2.2",
+  "license": "MIT",
+  "type": "module",
+  "typings": "dist/index.d.ts",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=16"
+  },
+  "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"
+    }
+  },
+  "prettier": {
+    "printWidth": 80,
+    "semi": true,
+    "singleQuote": true,
+    "trailingComma": "es5"
+  },
+  "name": "superjson",
+  "author": {
+    "name": "Simon Knott",
+    "email": "info@simonknott.de",
+    "url": "https://simonknott.de"
+  },
+  "contributors": [
+    {
+      "name": "Dylan Brookes",
+      "email": "dylan@brookes.net",
+      "url": "https://github.com/merelinguist"
+    },
+    {
+      "name": "Brandon Bayer",
+      "email": "b@bayer.w",
+      "url": "https://twitter.com/flybayer"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/blitz-js/superjson"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.5",
+    "@types/mongodb": "^3.6.12",
+    "@types/node": "^18.7.18",
+    "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",
+    "vitest": "^0.34.6"
+  },
+  "dependencies": {
+    "copy-anything": "^3.0.2"
+  },
+  "resolutions": {
+    "**/@typescript-eslint/eslint-plugin": "^4.11.1",
+    "**/@typescript-eslint/parser": "^4.11.1"
+  }
+}