14705802410

Committed 28 Apr 2025 10:42AM UTC coverage: 93.512%. First build

Build # 14705802410

Build Type

Pull #7248

github

Committed by

web-flow

Commit Message

Merge 1790e77c5 into f21888038

Pull Request Pull Request #7248: fix: Reduce the flatpack JSON size

Run Details

11784 of 13590 branches covered (86.71%)

117 of 138 new or added lines in 5 files covered. (84.78%)

15322 of 16385 relevant lines covered (93.51%)

31433.2 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.89

/packages/flatpack-json/src/flatpackUtil.mts

import assert from 'node:assert';

import {
    ArrayRefElement,
    BigIntRefElement,
    DateRefElement,
    MapRefElement,
    NumberRefElement,
    ObjectRefElement,
    ObjectWrapperRefElement,
    PrimitiveRefElement,
    RefElements,
    RegExpRefElement,
    SetRefElement,
    StringConcatRefElement,
    StringPrimitiveRefElement,
    SubStringRefElement,
} from './RefElements.mjs';
import {
    ArrayBasedElements,
    type ArrayElement,
    ElementType,
    Flatpacked,
    type FlattenedElement,
    ObjectWrapperElement,
    supportedHeaders,
} from './types.mjs';

export function fromElement(elem: FlattenedElement, resolve: (index: number) => RefElements): RefElements {
    function handleArrayElement(element: ArrayBasedElements) {
        switch (element[0]) {
            case ElementType.Array: {
                break;
            }
            case ElementType.Object: {
                if (element[1] === 0 && element[2]) {
                    return ObjectWrapperRefElement.fromJSON(element as ObjectWrapperElement, resolve);
                }
                return ObjectRefElement.fromJSON(element, resolve);
            }
            case ElementType.String: {
                return StringConcatRefElement.fromJSON(element, resolve);
            }
            case ElementType.SubString: {
                return SubStringRefElement.fromJSON(element, resolve);
            }
            case ElementType.Set: {
                return SetRefElement.fromJSON(element, resolve);
            }
            case ElementType.Map: {
                return MapRefElement.fromJSON(element, resolve);
            }
            case ElementType.RegExp: {
                return RegExpRefElement.fromJSON(element, resolve);
            }
            case ElementType.Date: {
                return DateRefElement.fromJSON(element);
            }
            case ElementType.BigInt: {
                return BigIntRefElement.fromJSON(element, resolve);
            }
        }
        return ArrayRefElement.fromJSON(element as ArrayElement, resolve);
    }

    if (Array.isArray(elem)) {
        return handleArrayElement(elem as ArrayBasedElements);
    }

    if (typeof elem === 'string') {
        return StringPrimitiveRefElement.fromJSON(elem);
    }

    if (typeof elem === 'number') {
        return NumberRefElement.fromJSON(elem);
    }

    if (typeof elem === 'object') {
        if (elem === null) {
            return PrimitiveRefElement.fromJSON(elem);
        }
        return new ObjectRefElement();
    }

    assert(typeof elem === 'boolean');
    return PrimitiveRefElement.fromJSON(elem);
}

export function fromFlatpacked(flat: Flatpacked): RefElements[] {
    const elements: RefElements[] = [];

    const known = new Map<number, RefElements>();

    function resolve(index: number) {
        const found = known.get(index);
        if (found) return found;
        const element = fromElement(flat[index], resolve);
        known.set(index, element);
        elements[index] = element;
        element.setId(index);
        return element;
    }

    elements[0] = new PrimitiveRefElement(undefined);
    known.set(0, elements[0]);

    for (let i = 1; i < flat.length; i++) {
        resolve(i);
    }

    return elements;
}

export class FlatpackedWrapper {
    constructor(readonly elements: Flatpacked) {}
    static parse(content: string): FlatpackedWrapper {
        const data = JSON.parse(content);
        assert(isFlatpacked(data));
        return new FlatpackedWrapper(data);
    }

    toRefElements(): RefElements[] {
        return fromFlatpacked(this.elements);
    }
}

export function isFlatpacked(value: unknown): value is Flatpacked {
    return Array.isArray(value) && typeof value[0] === 'string' && supportedHeaders.has(value[0]);
}

1	import assert from 'node:assert';
2
3	import {
4	ArrayRefElement,
5	BigIntRefElement,
6	DateRefElement,
7	MapRefElement,
8	NumberRefElement,
9	ObjectRefElement,
10	ObjectWrapperRefElement,
11	PrimitiveRefElement,
12	RefElements,
13	RegExpRefElement,
14	SetRefElement,
15	StringConcatRefElement,
16	StringPrimitiveRefElement,
17	SubStringRefElement,
18	} from './RefElements.mjs';
19	import {
20	ArrayBasedElements,
21	type ArrayElement,
22	ElementType,
23	Flatpacked,
24	type FlattenedElement,
25	ObjectWrapperElement,
26	supportedHeaders,
27	} from './types.mjs';
28
29	export function fromElement(elem: FlattenedElement, resolve: (index: number) => RefElements): RefElements {
30	function handleArrayElement(element: ArrayBasedElements) {
31	switch (element[0]) {	213✔
32	case ElementType.Array: {
33	break;	86✔
34	}
35	case ElementType.Object: {
36	if (element[1] === 0 && element[2]) {	39✔
37	return ObjectWrapperRefElement.fromJSON(element as ObjectWrapperElement, resolve);	3✔
38	}
39	return ObjectRefElement.fromJSON(element, resolve);	36✔
40	}
41	case ElementType.String: {
42	return StringConcatRefElement.fromJSON(element, resolve);	37✔
43	}
44	case ElementType.SubString: {
45	return SubStringRefElement.fromJSON(element, resolve);	26✔
46	}
47	case ElementType.Set: {
48	return SetRefElement.fromJSON(element, resolve);	5✔
49	}
50	case ElementType.Map: {
51	return MapRefElement.fromJSON(element, resolve);	3✔
52	}
53	case ElementType.RegExp: {
54	return RegExpRefElement.fromJSON(element, resolve);	7✔
55	}
56	case ElementType.Date: {
57	return DateRefElement.fromJSON(element);	3✔
58	}
59	case ElementType.BigInt: {
60	return BigIntRefElement.fromJSON(element, resolve);	7✔
61	}
62	}
63	return ArrayRefElement.fromJSON(element as ArrayElement, resolve);	86✔
64	}
65
66	if (Array.isArray(elem)) {	377✔
67	return handleArrayElement(elem as ArrayBasedElements);	213✔
68	}
69
70	if (typeof elem === 'string') {	164✔
71	return StringPrimitiveRefElement.fromJSON(elem);	127✔
72	}
73
74	if (typeof elem === 'number') {	37✔
75	return NumberRefElement.fromJSON(elem);	31✔
76	}
77
78	if (typeof elem === 'object') {	6✔
79	if (elem === null) {	2!
80	return PrimitiveRefElement.fromJSON(elem);	2✔
81	}
82	return new ObjectRefElement();	×
83	}
84
85	assert(typeof elem === 'boolean');	4✔
86	return PrimitiveRefElement.fromJSON(elem);	4✔
87	}
88
89	export function fromFlatpacked(flat: Flatpacked): RefElements[] {
90	const elements: RefElements[] = [];	59✔
91
92	const known = new Map<number, RefElements>();	59✔
93
94	function resolve(index: number) {
95	const found = known.get(index);	833✔
96	if (found) return found;	833✔
97	const element = fromElement(flat[index], resolve);	377✔
98	known.set(index, element);	377✔
99	elements[index] = element;	377✔
100	element.setId(index);	377✔
101	return element;	377✔
102	}
103
104	elements[0] = new PrimitiveRefElement(undefined);	59✔
105	known.set(0, elements[0]);	59✔
106
107	for (let i = 1; i < flat.length; i++) {	59✔
108	resolve(i);	377✔
109	}
110
111	return elements;	59✔
112	}
113
114	export class FlatpackedWrapper {
115	constructor(readonly elements: Flatpacked) {}	59✔
116	static parse(content: string): FlatpackedWrapper {
117	const data = JSON.parse(content);	×
118	assert(isFlatpacked(data));	×
119	return new FlatpackedWrapper(data);	×
120	}
121
122	toRefElements(): RefElements[] {
123	return fromFlatpacked(this.elements);	59✔
124	}
125	}
126
127	export function isFlatpacked(value: unknown): value is Flatpacked {
NEW 128	return Array.isArray(value) && typeof value[0] === 'string' && supportedHeaders.has(value[0]);	×
129	}

streetsidesoftware / cspell / 14705802410

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous