23342742569

Committed 20 Mar 2026 12:25PM UTC coverage: 93.002% (+0.1%) from 92.904%

Build # 23342742569

Build Type

Pull #8680

github

Committed by

web-flow

Commit Message

Merge ac80a4eef into c1c689764

Pull Request Pull Request #8680: fix: make flatpack diff friendly

Coverage Stats

9752 of 11594 branches covered (84.11%)

1187 of 1242 new or added lines in 17 files covered. (95.57%)

7 existing lines in 2 files now uncovered.

19364 of 20821 relevant lines covered (93.0%)

29840.7 hits per line

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

97.67

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

import assert from 'node:assert';

import { RefCounter } from './RefCounter.mjs';
import type { ArrayBasedElements, Flatpacked, FlatpackIndex, FlattenedElement, UnpackMetaData } from './types.mjs';
import { ElementType, isStringTableElement } from './types.mjs';

export function getIndexesReferencedByElement(elem: FlattenedElement): FlatpackIndex[] {
    function handleArrayElement(element: ArrayBasedElements): FlatpackIndex[] {
        switch (element[0]) {
            case ElementType.Array: {
                return element.slice(1);
            }
            case ElementType.Object: {
                return element.slice(1).filter((v) => !!v);
            }
            case ElementType.String: {
                return element.slice(1);
            }
            case ElementType.SubString: {
                return [element[1]];
            }
            case ElementType.Set: {
                return element.slice(1, 2);
            }
            case ElementType.Map: {
                return element.slice(1, 3);
            }
            case ElementType.RegExp: {
                return element.slice(1, 3);
            }
            case ElementType.Date: {
                return [];
            }
            case ElementType.BigInt: {
                return [element[1]];
            }
        }
        assert(false, 'Invalid element type');
    }

    if (!elem) {
        return [];
    }

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

    if (typeof elem === 'string') {
        return [];
    }

    if (typeof elem === 'number') {
        return [];
    }

    if (typeof elem === 'object') {
        return [];
    }

    assert(typeof elem === 'boolean', `Expected boolean, got ${typeof elem}`);
    return [];
}

export function getFlatpackedRootIdx(flatpack: Flatpacked): FlatpackIndex {
    let idx: FlatpackIndex = 1;
    if (isStringTableElement(flatpack[idx])) {
        idx++;
    }
    assert(!isStringTableElement(flatpack[idx]), 'String table element should be at index 1 if it exists');
    return idx;
}

export function getFlatpackedRoot(flatpack: Flatpacked): FlattenedElement {
    return flatpack[getFlatpackedRootIdx(flatpack)];
}

export function generateUnpackMetaData(flatpack: Flatpacked): UnpackMetaData {
    const referenced = new RefCounter<FlatpackIndex>();

    const rootIndex = getFlatpackedRootIdx(flatpack);
    calcReferenced(rootIndex);
    // Make sure the string table is always included.
    if (rootIndex > 1) {
        referenced.add(1);
    }

    const metaData: UnpackMetaData = {
        flatpack,
        referenced,
        rootIndex,
    };
    return metaData;

    function calcReferenced(idx: FlatpackIndex): void {
        if (!idx) return;
        if (referenced.isReferenced(idx)) {
            referenced.add(idx);
            return;
        }

        referenced.add(idx);
        for (const ref of getIndexesReferencedByElement(flatpack[idx])) {
            calcReferenced(ref);
        }
    }
}

1	import assert from 'node:assert';
2
3	import { RefCounter } from './RefCounter.mjs';
4	import type { ArrayBasedElements, Flatpacked, FlatpackIndex, FlattenedElement, UnpackMetaData } from './types.mjs';
5	import { ElementType, isStringTableElement } from './types.mjs';
6
7	export function getIndexesReferencedByElement(elem: FlattenedElement): FlatpackIndex[] {
8	function handleArrayElement(element: ArrayBasedElements): FlatpackIndex[] {
9	switch (element[0]) {	18,168✔
10	case ElementType.Array: {
11	return element.slice(1);	10,539✔
12	}
13	case ElementType.Object: {
14	return element.slice(1).filter((v) => !!v);	8,904✔
15	}
16	case ElementType.String: {
17	return element.slice(1);	1,958✔
18	}
19	case ElementType.SubString: {
20	return [element[1]];	1,153✔
21	}
22	case ElementType.Set: {
23	return element.slice(1, 2);	13✔
24	}
25	case ElementType.Map: {
26	return element.slice(1, 3);	8✔
27	}
28	case ElementType.RegExp: {
29	return element.slice(1, 3);	16✔
30	}
31	case ElementType.Date: {
32	return [];	7✔
33	}
34	case ElementType.BigInt: {
35	return [element[1]];	22✔
36	}
37	}
NEW 38	assert(false, 'Invalid element type');	×
39	}
40
41	if (!elem) {	20,839✔
42	return [];	75✔
43	}
44
45	if (Array.isArray(elem)) {	20,764✔
46	return handleArrayElement(elem as ArrayBasedElements);	18,168✔
47	}
48
49	if (typeof elem === 'string') {	2,596✔
50	return [];	2,511✔
51	}
52
53	if (typeof elem === 'number') {	85✔
54	return [];	72✔
55	}
56
57	if (typeof elem === 'object') {	13✔
58	return [];	9✔
59	}
60
61	assert(typeof elem === 'boolean', `Expected boolean, got ${typeof elem}`);	4✔
62	return [];	4✔
63	}
64
65	export function getFlatpackedRootIdx(flatpack: Flatpacked): FlatpackIndex {
66	let idx: FlatpackIndex = 1;	1,205✔
67	if (isStringTableElement(flatpack[idx])) {	1,205✔
68	idx++;	266✔
69	}
70	assert(!isStringTableElement(flatpack[idx]), 'String table element should be at index 1 if it exists');	1,205✔
71	return idx;	1,205✔
72	}
73
74	export function getFlatpackedRoot(flatpack: Flatpacked): FlattenedElement {
75	return flatpack[getFlatpackedRootIdx(flatpack)];	2✔
76	}
77
78	export function generateUnpackMetaData(flatpack: Flatpacked): UnpackMetaData {
79	const referenced = new RefCounter<FlatpackIndex>();	31✔
80
81	const rootIndex = getFlatpackedRootIdx(flatpack);	31✔
82	calcReferenced(rootIndex);	31✔
83	// Make sure the string table is always included.
84	if (rootIndex > 1) {	31!
85	referenced.add(1);	31✔
86	}
87
88	const metaData: UnpackMetaData = {	31✔
89	flatpack,
90	referenced,
91	rootIndex,
92	};
93	return metaData;	31✔
94
95	function calcReferenced(idx: FlatpackIndex): void {
96	if (!idx) return;	281✔
97	if (referenced.isReferenced(idx)) {	279✔
98	referenced.add(idx);	66✔
99	return;	66✔
100	}
101
102	referenced.add(idx);	213✔
103	for (const ref of getIndexesReferencedByElement(flatpack[idx])) {	213✔
104	calcReferenced(ref);	250✔
105	}
106	}
107	}

streetsidesoftware / cspell / 23342742569

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