23435280550

Committed 23 Mar 2026 11:34AM UTC coverage: 93.044% (+0.1%) from 92.904%

Build # 23435280550

Build Type

Pull #8680

github

Committed by

web-flow

Commit Message

Merge 4b29a808f into 6231c85df

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

Coverage Stats

9613 of 11431 branches covered (84.1%)

1318 of 1354 new or added lines in 18 files covered. (97.34%)

8 existing lines in 3 files now uncovered.

19140 of 20571 relevant lines covered (93.04%)

30228.78 hits per line

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

98.15

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

import assert from 'node:assert';

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

export function getIndexesReferencedByElement(elem: FlattenedElement): FlatpackIndex[] {
    if (!elem) {
        return [];
    }

    if (Array.isArray(elem)) {
        return extractElementIndexes(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 [];
}

function extractElementIndexes(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]];
        }
    }
    if (!element.length) return [];
    assert(false, 'Invalid element type.');
}

export function extractObjectKeyAndValueIndexes(elem: FlattenedElement): FlatpackIndex[] {
    if (!elem || typeof elem !== 'object' || !Array.isArray(elem)) return [];

    const element = elem as ArrayBasedElements;

    switch (element[0]) {
        case ElementType.Object: {
            return element.slice(1).filter((v) => !!v);
        }
        case ElementType.Set: {
            return []; // element.slice(1, 2);
        }
        case ElementType.Map: {
            return []; // element.slice(1, 3);
        }
    }
    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);
        }
    }
}
export function isStringTableElement(elem: FlattenedElement): elem is StringTableElement {
    if (!Array.isArray(elem)) {
        return false;
    }
    return elem[0] === ElementType.StringTable;
}

1	import assert from 'node:assert';
2
3	import { RefCounter } from './RefCounter.mjs';
4	import type {
5	ArrayBasedElements,
6	Flatpacked,
7	FlatpackIndex,
8	FlattenedElement,
9	StringTableElement,
10	UnpackMetaData,
11	} from './types.mjs';
12	import { ElementType } from './types.mjs';
13
14	export function getIndexesReferencedByElement(elem: FlattenedElement): FlatpackIndex[] {
15	if (!elem) {	119,496✔
16	return [];	38,206✔
17	}
18
19	if (Array.isArray(elem)) {	81,290✔
20	return extractElementIndexes(elem as ArrayBasedElements);	78,250✔
21	}
22
23	if (typeof elem === 'string') {	3,040✔
24	return [];	2,515✔
25	}
26
27	if (typeof elem === 'number') {	525✔
28	return [];	428✔
29	}
30
31	if (typeof elem === 'object') {	97✔
32	return [];	69✔
33	}
34
35	assert(typeof elem === 'boolean', `Expected boolean, got ${typeof elem}`);	28✔
36	return [];	28✔
37	}
38
39	function extractElementIndexes(element: ArrayBasedElements): FlatpackIndex[] {
40	switch (element[0]) {	78,250✔
41	case ElementType.Array: {
42	return element.slice(1);	37,289✔
43	}
44	case ElementType.Object: {
45	return element.slice(1).filter((v) => !!v);	24,192✔
46	}
47	case ElementType.String: {
48	return element.slice(1);	2,000✔
49	}
50	case ElementType.SubString: {
51	return [element[1]];	1,153✔
52	}
53	case ElementType.Set: {
54	return element.slice(1, 2);	56✔
55	}
56	case ElementType.Map: {
57	return element.slice(1, 3);	40✔
58	}
59	case ElementType.RegExp: {
60	return element.slice(1, 3);	61✔
61	}
62	case ElementType.Date: {
63	return [];	28✔
64	}
65	case ElementType.BigInt: {
66	return [element[1]];	64✔
67	}
68	}
69	if (!element.length) return [];	25,463!
NEW 70	assert(false, 'Invalid element type.');	×
71	}
72
73	export function extractObjectKeyAndValueIndexes(elem: FlattenedElement): FlatpackIndex[] {
74	if (!elem \|\| typeof elem !== 'object' \|\| !Array.isArray(elem)) return [];	3,686✔
75
76	const element = elem as ArrayBasedElements;	3,435✔
77
78	switch (element[0]) {	3,435✔
79	case ElementType.Object: {
80	return element.slice(1).filter((v) => !!v);	2,980✔
81	}
82	case ElementType.Set: {
83	return []; // element.slice(1, 2);	21✔
84	}
85	case ElementType.Map: {
86	return []; // element.slice(1, 3);	17✔
87	}
88	}
89	return [];	1,907✔
90	}
91
92	export function getFlatpackedRootIdx(flatpack: Flatpacked): FlatpackIndex {
93	let idx: FlatpackIndex = 1;	3,039✔
94	if (isStringTableElement(flatpack[idx])) {	3,039✔
95	idx++;	2,342✔
96	}
97	assert(!isStringTableElement(flatpack[idx]), 'String table element should be at index 1 if it exists');	3,039✔
98	return idx;	3,039✔
99	}
100
101	export function getFlatpackedRoot(flatpack: Flatpacked): FlattenedElement {
102	return flatpack[getFlatpackedRootIdx(flatpack)];	2✔
103	}
104
105	export function generateUnpackMetaData(flatpack: Flatpacked): UnpackMetaData {
106	const referenced = new RefCounter<FlatpackIndex>();	171✔
107
108	const rootIndex = getFlatpackedRootIdx(flatpack);	171✔
109	calcReferenced(rootIndex);	171✔
110	// Make sure the string table is always included.
111	if (rootIndex > 1) {	171!
112	referenced.add(1);	171✔
113	}
114
115	const metaData: UnpackMetaData = {	171✔
116	flatpack,
117	referenced,
118	rootIndex,
119	};
120	return metaData;	171✔
121
122	function calcReferenced(idx: FlatpackIndex): void {
123	if (!idx) return;	5,042✔
124	if (referenced.isReferenced(idx)) {	5,040✔
125	referenced.add(idx);	1,532✔
126	return;	1,532✔
127	}
128
129	referenced.add(idx);	3,508✔
130	for (const ref of getIndexesReferencedByElement(flatpack[idx])) {	3,508✔
131	calcReferenced(ref);	4,871✔
132	}
133	}
134	}
135	export function isStringTableElement(elem: FlattenedElement): elem is StringTableElement {
136	if (!Array.isArray(elem)) {	7,512✔
137	return false;	1,826✔
138	}
139	return elem[0] === ElementType.StringTable;	5,686✔
140	}

streetsidesoftware / cspell / 23435280550

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