@cspell/normalize-json 8.14.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jason Dent
+
+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.

package/README.md

@@ -0,0 +1,17 @@
+# `@cspell/normalize-json`
+
+A library to reduce the size of JSON data by flattening and normalizing the values.
+
+It is similar to [flatted](https://www.npmjs.com/package/flatted).
+
+## Install
+
+```sh
+npm install -S @cspell/normalize-json
+```
+
+## Usage
+
+```ts
+import { parse, stringify } from '@cspell/normalize-json';
+```

package/dist/dehydrate.d.mts

@@ -0,0 +1,53 @@
+type Primitive = string | number | boolean | null | undefined | RegExp | Date | bigint;
+type PrimitiveSet = Set<Primitive | PrimitiveObject | PrimitiveArray | PrimitiveSet | PrimitiveMap>;
+type PrimitiveMap = Map<Primitive | PrimitiveObject | PrimitiveArray | PrimitiveSet | PrimitiveMap, Primitive | PrimitiveObject | PrimitiveArray | PrimitiveSet | PrimitiveMap>;
+interface PrimitiveObject {
+    readonly [key: string]: Primitive | PrimitiveObject | PrimitiveArray | PrimitiveSet | PrimitiveMap;
+}
+type PrimitiveArray = readonly (Primitive | PrimitiveObject | PrimitiveArray | PrimitiveSet | PrimitiveMap)[];
+type PrimitiveElement = Primitive;
+type Serializable = Primitive | PrimitiveObject | PrimitiveArray | PrimitiveSet | PrimitiveMap;
+declare enum ElementType {
+    Array = 0,
+    Object = 1,
+    String = 2,
+    SubString = 3,
+    Set = 4,
+    Map = 5,
+    RegExp = 6,
+    Date = 7,
+    BigInt = 8
+}
+interface EmptyObject {
+    readonly t?: ElementType.Object;
+}
+type ObjectBasedElements = EmptyObject;
+type ArrayBasedElements = ArrayElement | BigIntElement | DateElement | MapElement | ObjectElement | RegExpElement | SetElement | StringElement | SubStringElement;
+type Index = number;
+type StringElement = readonly [type: ElementType.String, ...Index[]];
+type SubStringElement = readonly [type: ElementType.SubString, Index, len: number, offset?: number];
+type ObjectElement = readonly [type: ElementType.Object, keys: Index, values: Index];
+type SetElement = readonly [type: ElementType.Set, keys: Index];
+type MapElement = readonly [type: ElementType.Map, keys: Index, values: Index];
+type RegExpElement = readonly [type: ElementType.RegExp, pattern: Index, flags: Index];
+type DateElement = readonly [type: ElementType.Date, value: number];
+type BigIntElement = readonly [type: ElementType.BigInt, value: Index];
+type ArrayElement = readonly [type: ElementType.Array, ...Index[]];
+type Element = Readonly<PrimitiveElement | ObjectBasedElements | ArrayBasedElements>;
+type Header = string;
+type Dehydrated = [Header, ...Element[]];
+type Hydrated = Readonly<Serializable>;
+export interface NormalizeJsonOptions {
+    sortKeys?: boolean;
+    /**
+     * Dedupe objects and arrays.
+     * Implies `sortKeys`.
+     */
+    dedupe?: boolean;
+}
+export declare function toJSON<V extends Serializable>(json: V, options?: NormalizeJsonOptions): Dehydrated;
+export declare function fromJSON(data: Dehydrated): Hydrated;
+export declare function parse(data: string): Hydrated;
+export declare function stringify(data: Hydrated): string;
+export {};
+//# sourceMappingURL=dehydrate.d.mts.map

package/dist/dehydrate.mjs

@@ -0,0 +1,524 @@
+import assert from 'node:assert';
+var ElementType;
+(function (ElementType) {
+    ElementType[ElementType["Array"] = 0] = "Array";
+    ElementType[ElementType["Object"] = 1] = "Object";
+    ElementType[ElementType["String"] = 2] = "String";
+    ElementType[ElementType["SubString"] = 3] = "SubString";
+    ElementType[ElementType["Set"] = 4] = "Set";
+    ElementType[ElementType["Map"] = 5] = "Map";
+    ElementType[ElementType["RegExp"] = 6] = "RegExp";
+    ElementType[ElementType["Date"] = 7] = "Date";
+    ElementType[ElementType["BigInt"] = 8] = "BigInt";
+})(ElementType || (ElementType = {}));
+const blockSplitRegex = /^sha\d/;
+const dataHeader = 'Dehydrated JSON v1';
+const collator = new Intl.Collator('en', {
+    usage: 'sort',
+    numeric: true,
+    sensitivity: 'variant',
+    caseFirst: 'upper',
+    ignorePunctuation: false,
+});
+const compare = collator.compare;
+const forceStringPrimitives = false;
+const minSubStringLen = 4;
+export function toJSON(json, options) {
+    const data = [dataHeader];
+    const dedupe = options?.dedupe ?? true;
+    const sortKeys = options?.sortKeys || dedupe;
+    let emptyObjIdx = 0;
+    const cache = new Map([[undefined, 0]]);
+    const referenced = new Set();
+    const cachedArrays = new Map();
+    const knownStrings = new Trie();
+    const cachedElements = new Map();
+    function primitiveToIdx(value) {
+        if (typeof value === 'string')
+            return stringToIdx(value);
+        if (typeof value === 'bigint')
+            return bigintToIdx(value);
+        const found = cache.get(value);
+        if (found !== undefined) {
+            return found;
+        }
+        const idx = data.push(value) - 1;
+        cache.set(value, idx);
+        return idx;
+    }
+    function addSubStringRef(idxString, value, offset) {
+        const found = cache.get(value);
+        if (found !== undefined) {
+            return found;
+        }
+        const sub = offset
+            ? [ElementType.SubString, idxString, value.length, offset]
+            : [ElementType.SubString, idxString, value.length];
+        const idx = data.push(sub) - 1;
+        cache.set(value, idx);
+        return idx;
+    }
+    function addKnownString(idx, value) {
+        if (value.length >= minSubStringLen) {
+            knownStrings.add(value.length > 256 ? value.slice(0, 256) : value, { idx });
+        }
+    }
+    function addStringPrimitive(value) {
+        const idx = data.push(value) - 1;
+        addKnownString(idx, value);
+        cache.set(value, idx);
+        return idx;
+    }
+    function duplicateIndex(idx) {
+        const element = data[idx];
+        const duplicate = data.push(element) - 1;
+        return duplicate;
+    }
+    function stringToIdx(value) {
+        const found = cache.get(value);
+        if (found !== undefined) {
+            return found;
+        }
+        if (forceStringPrimitives || value.length < minSubStringLen || blockSplitRegex.test(value)) {
+            return addStringPrimitive(value);
+        }
+        const trieFound = knownStrings.find(value);
+        if (!trieFound || !trieFound.data || trieFound.found.length < minSubStringLen) {
+            return addStringPrimitive(value);
+        }
+        const { data: tData, found: subStr } = trieFound;
+        const sIdx = addSubStringRef(tData.idx, subStr, tData.offset);
+        if (subStr === value)
+            return sIdx;
+        const v = [sIdx, stringToIdx(value.slice(subStr.length))];
+        const idx = data.push([ElementType.String, ...v]) - 1;
+        cache.set(value, idx);
+        addKnownString(idx, value);
+        return idx;
+    }
+    function objSetToIdx(value) {
+        const found = cache.get(value);
+        if (found !== undefined) {
+            referenced.add(found);
+            return found;
+        }
+        const idx = data.push(0) - 1;
+        cache.set(value, idx);
+        const keys = [...value];
+        const k = createUniqueKeys(keys);
+        const element = [ElementType.Set, k];
+        return storeElement(value, idx, element);
+    }
+    function createUniqueKeys(keys) {
+        let k = arrToIdx(keys);
+        const elementKeys = data[k];
+        const uniqueKeys = new Set(elementKeys.slice(1));
+        if (uniqueKeys.size !== keys.length) {
+            // one or more of the keys got deduped. We need to duplicate it.
+            uniqueKeys.clear();
+            const indexes = elementKeys.slice(1).map((idx) => {
+                if (uniqueKeys.has(idx)) {
+                    return duplicateIndex(idx);
+                }
+                uniqueKeys.add(idx);
+                return idx;
+            });
+            k = createArrayElementFromIndexValues(data.length, indexes);
+        }
+        return k;
+    }
+    function objMapToIdx(value) {
+        const found = cache.get(value);
+        if (found !== undefined) {
+            referenced.add(found);
+            return found;
+        }
+        const idx = data.push(0) - 1;
+        cache.set(value, idx);
+        const entries = [...value.entries()];
+        const k = createUniqueKeys(entries.map(([key]) => key));
+        const v = arrToIdx(entries.map(([, value]) => value));
+        const element = [ElementType.Map, k, v];
+        return storeElement(value, idx, element);
+    }
+    function objRegExpToIdx(value) {
+        const found = cache.get(value);
+        if (found !== undefined) {
+            return found;
+        }
+        const idx = data.push(0) - 1;
+        cache.set(value, idx);
+        const element = [ElementType.RegExp, stringToIdx(value.source), stringToIdx(value.flags)];
+        return storeElement(value, idx, element);
+    }
+    function objDateToIdx(value) {
+        const found = cache.get(value);
+        if (found !== undefined) {
+            return found;
+        }
+        const idx = data.push(0) - 1;
+        cache.set(value, idx);
+        const element = [ElementType.Date, value.getTime()];
+        return storeElement(value, idx, element);
+    }
+    function bigintToIdx(value) {
+        const found = cache.get(value);
+        if (found !== undefined) {
+            return found;
+        }
+        const idx = data.push(0) - 1;
+        cache.set(value, idx);
+        const element = [
+            ElementType.BigInt,
+            primitiveToIdx(value <= Number.MAX_SAFE_INTEGER && value >= -Number.MAX_SAFE_INTEGER
+                ? Number(value)
+                : value.toString()),
+        ];
+        return storeElement(value, idx, element);
+    }
+    function objToIdx(value) {
+        const found = cache.get(value);
+        if (found !== undefined) {
+            referenced.add(found);
+            return found;
+        }
+        if (isObjectWrapper(value)) {
+            const idx = data.push({}) - 1;
+            cache.set(value, idx);
+            const element = [ElementType.Object, 0, valueToIdx(value.valueOf())];
+            return storeElement(value, idx, element);
+        }
+        const entries = Object.entries(value);
+        if (!entries.length) {
+            if (emptyObjIdx) {
+                return emptyObjIdx;
+            }
+            const idx = data.push({}) - 1;
+            emptyObjIdx = idx;
+            return idx;
+        }
+        const idx = data.push(0) - 1;
+        cache.set(value, idx);
+        if (sortKeys) {
+            entries.sort(([a], [b]) => compare(a, b));
+        }
+        const k = arrToIdx(entries.map(([key]) => key));
+        const v = arrToIdx(entries.map(([, value]) => value));
+        const element = [ElementType.Object, k, v];
+        return storeElement(value, idx, element);
+    }
+    function storeElement(value, idx, element) {
+        const useIdx = dedupe ? cacheElement(idx, element) : idx;
+        if (useIdx !== idx && idx === data.length - 1) {
+            data.length = idx;
+            cache.set(value, useIdx);
+            return useIdx;
+        }
+        data[idx] = element;
+        return idx;
+    }
+    function cacheElement(elemIdx, element) {
+        let map = cachedElements;
+        for (let i = 0; i < element.length - 1; i++) {
+            const idx = element[i];
+            let found = map.get(idx);
+            if (!found) {
+                found = new Map();
+                map.set(idx, found);
+            }
+            assert(found instanceof Map);
+            map = found;
+        }
+        const idx = element[element.length - 1];
+        const foundIdx = map.get(idx);
+        if (typeof foundIdx === 'number') {
+            return referenced.has(elemIdx) ? elemIdx : foundIdx;
+        }
+        map.set(idx, elemIdx);
+        return elemIdx;
+    }
+    function stashArray(idx, element) {
+        const indexHash = simpleHash(element);
+        let found = cachedArrays.get(indexHash);
+        if (!found) {
+            found = [];
+            cachedArrays.set(indexHash, found);
+        }
+        const foundIdx = found.find((entry) => isEqual(entry.v, element));
+        if (foundIdx) {
+            return referenced.has(idx) ? idx : foundIdx.idx;
+        }
+        found.push({ idx, v: element });
+        return idx;
+    }
+    function createArrayElementFromIndexValues(idx, indexValues) {
+        const element = [ElementType.Array, ...indexValues];
+        const useIdx = dedupe ? stashArray(idx, element) : idx;
+        if (useIdx !== idx) {
+            assert(data.length == idx + 1, `Expected ${idx + 1} but got ${data.length}`);
+            data.length = idx;
+            return useIdx;
+        }
+        data[idx] = element;
+        return idx;
+    }
+    function arrToIdx(value) {
+        const found = cache.get(value);
+        if (found !== undefined) {
+            referenced.add(found);
+            return found;
+        }
+        const idx = data.push(0) - 1;
+        cache.set(value, idx);
+        const useIdx = createArrayElementFromIndexValues(idx, value.map((idx) => valueToIdx(idx)));
+        cache.set(value, useIdx);
+        return useIdx;
+    }
+    function valueToIdx(value) {
+        if (value === null) {
+            // eslint-disable-next-line unicorn/no-null
+            return primitiveToIdx(null);
+        }
+        if (typeof value === 'object') {
+            if (value instanceof Set) {
+                return objSetToIdx(value);
+            }
+            if (value instanceof Map) {
+                return objMapToIdx(value);
+            }
+            if (value instanceof RegExp) {
+                return objRegExpToIdx(value);
+            }
+            if (Array.isArray(value)) {
+                return arrToIdx(value);
+            }
+            if (value instanceof Date) {
+                return objDateToIdx(value);
+            }
+            return objToIdx(value);
+        }
+        return primitiveToIdx(value);
+    }
+    valueToIdx(json);
+    return data;
+}
+function isEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+function simpleHash(values) {
+    let hash = Math.sqrt(values.length);
+    for (const value of values) {
+        hash += value * value;
+    }
+    return hash;
+}
+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;
+}
+function isObjectWrapper(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.valueOf === 'function' &&
+        value.valueOf() !== value);
+}
+class Trie {
+    root = { d: undefined, c: new Map() };
+    add(key, data) {
+        let node = this.root;
+        for (const k of key) {
+            let c = node.c;
+            if (!c) {
+                node.c = c = new Map();
+            }
+            let n = c.get(k);
+            if (!n) {
+                c.set(k, (n = { d: data }));
+            }
+            node = n;
+        }
+    }
+    find(key) {
+        let node = this.root;
+        let found = '';
+        for (const k of key) {
+            const c = node.c;
+            if (!c) {
+                break;
+            }
+            const n = c.get(k);
+            if (!n) {
+                break;
+            }
+            found += k;
+            node = n;
+        }
+        return { data: node.d, found };
+    }
+}
+export function parse(data) {
+    return fromJSON(JSON.parse(data));
+}
+export function stringify(data) {
+    return JSON.stringify(toJSON(data));
+}
+//# sourceMappingURL=dehydrate.mjs.map

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { fromJSON, parse, stringify, toJSON } from './dehydrate.mjs';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,2 @@
+export { fromJSON, parse, stringify, toJSON } from './dehydrate.mjs';
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@cspell/normalize-json",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "8.14.1",
+  "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/cspell-filetypes#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/cspell-filetypes"
+  },
+  "bugs": {
+    "url": "https://github.com/streetsidesoftware/cspell/labels/filetype"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@cspell/filetypes": "8.14.1"
+  },
+  "gitHead": "5552bdba15adc8c073dd33791f30329147c5c64b"
+}