23410982485

Committed 22 Mar 2026 07:42PM UTC coverage: 93.033% (+0.1%) from 92.904%

Build # 23410982485

Build Type

Pull #8680

github

Committed by

web-flow

Commit Message

Merge 0a1157d35 into fc7b60b0f

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

Coverage Stats

9600 of 11415 branches covered (84.1%)

1299 of 1336 new or added lines in 17 files covered. (97.23%)

8 existing lines in 3 files now uncovered.

19121 of 20553 relevant lines covered (93.03%)

30216.63 hits per line

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

98.04

/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[] {
    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);
        }
    }
}

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

streetsidesoftware / cspell / 23410982485

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