flatpack-json 8.14.3

package/dist/unpack.mjs

@@ -0,0 +1,163 @@
+import assert from 'node:assert';
+import { dataHeader, ElementType, } from './types.mjs';
+export function fromJSON(data) {
+    const [header] = data;
+    if (header !== dataHeader) {
+        throw new Error('Invalid header');
+    }
+    const cache = new Map([[0, undefined]]);
+    /**
+     * indexes that have been referenced by other objects.
+     */
+    const referenced = new Set();
+    function mergeKeysValues(keys, values) {
+        return keys.map((key, i) => [key, values[i]]);
+    }
+    function toSet(idx, elem) {
+        const [_, k] = elem;
+        const s = k ? new Set(idxToArr(k)) : new Set();
+        cache.set(idx, s);
+        return s;
+    }
+    function toMap(idx, elem) {
+        const [_, k, v] = elem;
+        const m = !k || !v ? new Map() : new Map(mergeKeysValues(idxToArr(k), idxToArr(v)));
+        cache.set(idx, m);
+        return m;
+    }
+    function toRegExp(idx, elem) {
+        const [_, pattern, flags] = elem;
+        const p = idxToValue(pattern);
+        const f = idxToValue(flags);
+        const r = new RegExp(p, f);
+        cache.set(idx, r);
+        return r;
+    }
+    function toBigInt(idx, elem) {
+        const [_, vIdx] = elem;
+        const r = BigInt(idxToValue(vIdx));
+        cache.set(idx, r);
+        return r;
+    }
+    function toDate(idx, elem) {
+        const [_, value] = elem;
+        const r = new Date(value);
+        cache.set(idx, r);
+        return r;
+    }
+    function toString(idx, elem) {
+        const s = typeof elem === 'string' ? elem : idxToValue(elem.slice(1));
+        cache.set(idx, s);
+        return s;
+    }
+    function toObj(idx, elem) {
+        const [_, k, v] = elem;
+        // Object Wrapper
+        if (!k && v) {
+            const obj = Object(idxToValue(v));
+            cache.set(idx, obj);
+            return obj;
+        }
+        const obj = {};
+        cache.set(idx, obj);
+        if (!k || !v)
+            return obj;
+        const keys = idxToArr(k);
+        const values = idxToArr(v);
+        Object.assign(obj, Object.fromEntries(mergeKeysValues(keys, values)));
+        return obj;
+    }
+    function idxToArr(idx) {
+        const element = data[idx];
+        assert(isArrayElement(element));
+        return toArr(idx, element);
+    }
+    function toArr(idx, element) {
+        const placeHolder = [];
+        const refs = element.slice(1);
+        cache.set(idx, placeHolder);
+        const arr = refs.map(idxToValue);
+        // check if the array has been referenced by another object.
+        if (!referenced.has(idx)) {
+            // It has not, just replace the placeholder with the array.
+            cache.set(idx, arr);
+            return arr;
+        }
+        placeHolder.push(...arr);
+        return placeHolder;
+    }
+    function handleSubStringElement(idx, refs) {
+        const [_t, sIdx, len, offset = 0] = refs;
+        const s = `${idxToValue(sIdx)}`.slice(offset, offset + len);
+        cache.set(idx, s);
+        return s;
+    }
+    function handleArrayElement(idx, element) {
+        switch (element[0]) {
+            case ElementType.Array: {
+                break;
+            }
+            case ElementType.Object: {
+                return toObj(idx, element);
+            }
+            case ElementType.String: {
+                return toString(idx, element);
+            }
+            case ElementType.SubString: {
+                return handleSubStringElement(idx, element);
+            }
+            case ElementType.Set: {
+                return toSet(idx, element);
+            }
+            case ElementType.Map: {
+                return toMap(idx, element);
+            }
+            case ElementType.RegExp: {
+                return toRegExp(idx, element);
+            }
+            case ElementType.Date: {
+                return toDate(idx, element);
+            }
+            case ElementType.BigInt: {
+                return toBigInt(idx, element);
+            }
+        }
+        return toArr(idx, element);
+    }
+    function idxToValue(idx) {
+        if (!idx)
+            return undefined;
+        const found = cache.get(idx);
+        if (found !== undefined) {
+            if (typeof idx === 'number')
+                referenced.add(idx);
+            return found;
+        }
+        if (Array.isArray(idx)) {
+            // it is a nested string;
+            const parts = idx.map((i) => idxToValue(i));
+            return joinToString(parts);
+        }
+        const element = data[idx];
+        if (typeof element === 'object') {
+            // eslint-disable-next-line unicorn/no-null
+            if (element === null)
+                return null;
+            if (Array.isArray(element))
+                return handleArrayElement(idx, element);
+            return {};
+        }
+        return element;
+    }
+    return idxToValue(1);
+}
+function joinToString(parts) {
+    return parts.map((a) => (Array.isArray(a) ? joinToString(a) : a)).join('');
+}
+function isArrayElement(value) {
+    return Array.isArray(value) && value[0] === ElementType.Array;
+}
+export function parse(data) {
+    return fromJSON(JSON.parse(data));
+}
+//# sourceMappingURL=unpack.mjs.map

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "flatpack-json",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "8.14.3",
+  "description": "A library to normalize JSON objects to reduce the size.",
+  "keywords": [
+    "cspell",
+    "json",
+    "normalize",
+    "flatten"
+  ],
+  "author": "Jason Dent <jason@streetsidesoftware.nl>",
+  "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/flatpack-json#readme",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "directories": {
+    "dist": "dist"
+  },
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "!**/*.tsbuildInfo",
+    "!**/__mocks__",
+    "!**/*.test.*",
+    "!**/*.spec.*",
+    "!**/*.map"
+  ],
+  "scripts": {
+    "build": "tsc -p .",
+    "watch": "tsc -p . -w",
+    "clean": "shx rm -rf dist temp coverage \"*.tsbuildInfo\"",
+    "clean-build": "pnpm run clean && pnpm run build",
+    "coverage": "vitest run --coverage",
+    "test-watch": "vitest",
+    "test": "vitest run"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/streetsidesoftware/cspell.git",
+    "directory": "packages/flatpack-json"
+  },
+  "bugs": {
+    "url": "https://github.com/streetsidesoftware/cspell/labels/filetype"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@cspell/filetypes": "8.14.3",
+    "diff": "^7.0.0"
+  },
+  "gitHead": "ce996377857f5d7c3e70f27fc512afbe605562f8"
+}