25249984834

Committed 02 May 2026 10:33AM UTC coverage: 98.808% (-0.2%) from 99.005%

Build # 25249984834

Build Type

push

github

Committed by

SignpostMarv

Commit Message

clean up known imports

Coverage Stats

591 of 609 branches covered (97.04%)

Branch coverage included in aggregate %.

5 of 5 new or added lines in 3 files covered. (100.0%)

44 existing lines in 3 files now uncovered.

4882 of 4930 relevant lines covered (99.03%)

22553.33 hits per line

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

95.45

/src/TypeScriptify/preprocessors/CollectValidateCalls.ts

import type {
} from '@signpostmarv/js-types';

import type {
        BinaryExpression,
        CallExpression,
        ElementAccessExpression,
        Identifier,
        Node,
        NodeArray,
        ObjectLiteralExpression,
        PropertyAccessExpression,
        PropertyAssignment,
        ShorthandPropertyAssignment,
        StringLiteral,
} from 'typescript';
import {
        isBinaryExpression,
        isCallExpression,
        isElementAccessExpression,
        isFunctionDeclaration,
        isIdentifier,
        isObjectLiteralExpression,
        isPropertyAccessExpression,
        isPropertyAssignment,
        isShorthandPropertyAssignment,
        isStringLiteral,
        SyntaxKind,
} from 'typescript';

import {
        ConditionalPreprocessor,
} from '../abstracts.ts';

import type {
        Config,
        specify_type_nested,
        specify_type_with_nested,
        specify_types_instance,
        validate_call_argument_1_match,
} from '../types.ts';

import type {
        prepend_with_imports,
} from '../TypeReferences.ts';
import {
        to_string,
        Types,
} from '../TypeReferences.ts';

type CandidateBinaryExpressionString = (
        & BinaryExpression
        & {
                left: Identifier,
                operatorToken: {
                        kind: SyntaxKind.PlusToken,
                },
                right: StringLiteral,
        }
);

type CandidateBinaryExpressionStringConcat = (
        & BinaryExpression
        & {
                left: CandidateBinaryExpressionString,
                operatorToken: {
                        kind: SyntaxKind.PlusToken,
                },
                right: (
                        | Identifier
                        | PropertyAccessExpression
                        | CallExpression
                ),
        }
);

type instancePath_initializer = (
        | StringLiteral
        | CandidateBinaryExpressionString
        | CandidateBinaryExpressionStringConcat
);

type argument_1_property_instancePath = (
        & (
                | ShorthandPropertyAssignment
                | (
                        & PropertyAssignment
                        & {
                                initializer: instancePath_initializer,
                        }
                )
        )
        & {
                name: (
                        & Identifier
                        & {
                                text: 'instancePath',
                        }
                ),
        }
);

type Candidate = (
        & CallExpression
        & {
                expression: (
                        & Identifier
                        & {
                                text: `validate${number}`,
                        }
                ),
                arguments: (
                        & NodeArray<(
                                | Identifier
                                | PropertyAccessExpression
                                | ObjectLiteralExpression
                                | ElementAccessExpression
                        )>
                        & {
                                length: 2,
                                0: (
                                        | Identifier
                                        | PropertyAccessExpression
                                        | ElementAccessExpression
                                ),
                                1: (
                                        & ObjectLiteralExpression
                                        & {
                                                properties: (
                                                        & NodeArray<PropertyAssignment>
                                                        & {
                                                                length: 5,
                                                                0: argument_1_property_instancePath,
                                                                2: (
                                                                        & PropertyAssignment
                                                                        & {
                                                                                name: (
                                                                                        & Identifier
                                                                                        & {
                                                                                                text: 'parentDataProperty',
                                                                                        }
                                                                                ),
                                                                                initializer: (
                                                                                        | StringLiteral
                                                                                        | Identifier
                                                                                ),
                                                                        }
                                                                ),
                                                        }
                                                ),
                                        }
                                ),
                        }
                ),
        }
);

const unique_id = Symbol('unique_id');

export type ValidateCallInfo = {
        name: string,

        // we're using null here as a placeholder for stuff we're not supporting
        instancePath: (
                | null
                | [string]
                | [string | null, ...(string | null)[]]
        ),

        parentDataProperty: string | null,

        [unique_id]: string,
};

export default class CollectValidateCalls extends ConditionalPreprocessor<
        Candidate
> {
        constructor(validate_calls: {
                [key: string]: [
                        ValidateCallInfo,
                        ...ValidateCallInfo[],
                ],
        }) {
                super(
                        (maybe): maybe is Candidate => (
                                isCallExpression(maybe)
                                && isIdentifier(maybe.expression)
                                && this.validate_function_name.test(maybe.expression.text)
                                && 2 === maybe.arguments.length
                                && (
                                        isIdentifier(maybe.arguments[0])
                                        || isPropertyAccessExpression(maybe.arguments[0])
                                        || isElementAccessExpression(maybe.arguments[0])
                                )
                                && isObjectLiteralExpression(maybe.arguments[1])
                                && 5 === maybe.arguments[1].properties.length
                                && (
                                        (
                                                isShorthandPropertyAssignment(
                                                        maybe.arguments[1].properties[0],
                                                )
                                                || (
                                                        isPropertyAssignment(
                                                                maybe.arguments[1].properties[0],
                                                        )
                                                        && this.#is_instancePath_initializer(
                                                                maybe.arguments[
                                                                        1
                                                                ].properties[
                                                                        0
                                                                ].initializer,
                                                        )
                                                )
                                        )
                                        && isIdentifier(
                                                maybe.arguments[1].properties[0].name,
                                        )
                                        && 'instancePath' === maybe.arguments[
                                                1
                                        ].properties[
                                                0
                                        ].name.text
                                )
                                && (
                                        isShorthandPropertyAssignment(
                                                maybe.arguments[1].properties[2],
                                        )
                                        || (
                                                isPropertyAssignment(maybe.arguments[1].properties[2])
                                                && (
                                                        isStringLiteral(
                                                                maybe.arguments[1].properties[2].initializer,
                                                        )
                                                        || isIdentifier(
                                                                maybe.arguments[1].properties[2].initializer,
                                                        )
                                                )
                                        )
                                )
                                && isIdentifier(maybe.arguments[1].properties[2].name)
                                && 'parentDataProperty' === (
                                        maybe.arguments[1].properties[2].name.text
                                )
                        ),
                        (node) => {
                                let checking: Node | undefined = node.parent;

                                while (checking) {
                                        if (
                                                isFunctionDeclaration(checking)
                                                && !!checking.name
                                                && isIdentifier(checking.name)
                                                && this.validate_function_name.test(
                                                        checking.name.text,
                                                )
                                        ) {
                                                const called_in = checking.name.getText();

                                                let instancePath: ValidateCallInfo['instancePath'];

                                                if (isShorthandPropertyAssignment(
                                                        node.arguments[1].properties[0],
                                                )) {
                                                        instancePath = null;
                                                } else if (isStringLiteral(
                                                        node.arguments[1].properties[0].initializer,
                                                )) {
                                                        instancePath = [
                                                                node.arguments[
                                                                        1
                                                                ].properties[
                                                                        0
                                                                ].initializer.text,
                                                        ];
                                                } else {
                                                        // oxlint-disable-next-line @stylistic/max-len
                                                        instancePath = this.#unpack_CandidateBinaryExpression(
                                                                node.arguments[1].properties[0].initializer,
                                                        );
                                                }

                                                const info: Omit<
                                                        ValidateCallInfo,
                                                        typeof unique_id
                                                > = {
                                                        name: node.expression.text,
                                                        instancePath,
                                                        parentDataProperty: (
                                                                (
                                                                        isPropertyAssignment(
                                                                                node.arguments[
                                                                                        1
                                                                                ].properties[
                                                                                        2
                                                                                ],
                                                                        )
                                                                        && isStringLiteral(
                                                                                node.arguments[
                                                                                        1
                                                                                ].properties[
                                                                                        2
                                                                                ].initializer,
                                                                        )
                                                                )
                                                                        ? node.arguments[
                                                                                1
                                                                        ].properties[
                                                                                2
                                                                        ].initializer.text
                                                                        : null
                                                        ),
                                                };

                                                const with_id: ValidateCallInfo = {
                                                        ...info,
                                                        [unique_id]: JSON.stringify(info),
                                                };

                                                if (!(called_in in validate_calls)) {
                                                        validate_calls[called_in] = [with_id];
                                                } else if (!validate_calls[called_in].find((
                                                        maybe,
                                                ) => maybe[unique_id] === with_id[unique_id])) {
                                                        validate_calls[called_in].push(with_id);
                                                }

                                                return true;
                                        }

                                        checking = checking.parent;
                                }

                                return false;
                        },
                );
        }

        #is_CandidateBinaryExpressionString(
                maybe: Node,
        ): maybe is CandidateBinaryExpressionString {
                return (
                        isBinaryExpression(maybe)
                        && (
                                isIdentifier(maybe.left)
                                || this.#is_CandidateBinaryExpressionStringConcat(maybe.left)
                        )
                        && SyntaxKind.PlusToken === maybe.operatorToken.kind
                        && isStringLiteral(maybe.right)
                );
        }

        #is_CandidateBinaryExpressionStringConcat(
                maybe: Node,
        ): maybe is CandidateBinaryExpressionStringConcat {
                return (
                        isBinaryExpression(maybe)
                        && (
                                this.#is_CandidateBinaryExpressionString(maybe.left)
                        )
                        && SyntaxKind.PlusToken === maybe.operatorToken.kind
                        && (
                                isIdentifier(maybe.right)
                                || isPropertyAccessExpression(maybe.right)
                                || isCallExpression(maybe.right)
                        )
                );
        }

        #is_instancePath_initializer(
                maybe: Node,
        ): maybe is instancePath_initializer {
                return (
                        isStringLiteral(maybe)
                        || this.#is_CandidateBinaryExpressionString(maybe)
                        || this.#is_CandidateBinaryExpressionStringConcat(maybe)
                );
        }

        #unpack_CandidateBinaryExpression(
                from: (
                        | CandidateBinaryExpressionString
                        | CandidateBinaryExpressionStringConcat
                ),
                current: (null | string)[] = [],
        ): [
                (string | null),
                ...(string | null)[],
        ] {
                if (isIdentifier(from.left)) {
                        return [
                                null,
                                (
                                        isStringLiteral(from.right)
                                                ? from.right.text
                                                : null
                                ),
                                ...current,
                        ];
                }

                return this.#unpack_CandidateBinaryExpression(from.left, [null]);
        }

        static specify_types_from_collected(
                info: {
                        [key: string]: [
                                ValidateCallInfo,
                                ...ValidateCallInfo[],
                        ],
                },
                config: Partial<Config>,
                existing: specify_types_instance,
                prepend_with_imports: prepend_with_imports,
        ) {
                this.#specify_types_from_collected_inside_out(
                        info,
                        config,
                        existing,
                        prepend_with_imports,
                );
                this.#specify_types_from_collected_outside_in(
                        info,
                        config,
                        existing,
                        prepend_with_imports,
                );
        }

        static #specify_types_from_collected_outside_in(
                info: {
                        [key: string]: [
                                ValidateCallInfo,
                                ...ValidateCallInfo[],
                        ],
                },
                config: Partial<Config>,
                existing: specify_types_instance,
                prepend_with_imports: prepend_with_imports,
        ) {
                const configurable = Object.entries(config.specify_types || {})
                        .filter((maybe): maybe is [
                                string,
                                specify_type_with_nested,
                        ] => 3 === maybe[1].length)
                        .map(([key, not_object]): [
                                string,
                                [
                                        ReturnType<(typeof Types)['toObject']>,
                                        (typeof not_object)[1],
                                        (typeof not_object)[2],
                                        string,
                                ],
                        ] => {
                                const as_object = Types.toObject(not_object[0]);

                                return [
                                        key,
                                        [
                                                as_object,
                                                not_object[1],
                                                not_object[2],
                                                to_string(as_object),
                                        ],
                                ];
                        });

                if (configurable.length < 1) {
                        return;
                }

                const existing_entries = Object.entries(existing);

                for (const [
                        ,
                        [
                                ,,
                                sub_types,
                                as_string,
                        ],
                ] of configurable) {
                        const found = existing_entries.find((maybe) => (
                                to_string(maybe[1]) === as_string
                        ));

                        if (!found) {
                                continue;
                        }

                        const [function_name] = found;

                        if (!(function_name in info)) {
                                continue;
                        }

                        this.#specify_types_from_collected_outside_in_deep_dive(
                                info,
                                function_name,
                                sub_types,
                                existing,
                                prepend_with_imports,
                        );
                }
        }

        static #specify_types_from_collected_inside_out(
                info: {
                        [key: string]: [
                                ValidateCallInfo,
                                ...ValidateCallInfo[],
                        ],
                },
                config: Partial<Config>,
                existing: specify_types_instance,
                prepend_with_imports: prepend_with_imports,
        ) {
                const configurable = config.specify_types_by_inside_out_match || [];

                if (configurable.length < 1) {
                        return;
                }

                const info_entries = Object.entries(info);

                for (const [
                        sub_type,
                        source,
                        match_with,
                        parent_is,
                ] of configurable) {
                        for (const [parent_function, has_calls] of info_entries) {
                                const checking = this.#filter_info(
                                        match_with,
                                        has_calls,
                                );

                                if (1 === checking.length) {
                                        if (!(source in prepend_with_imports)) {
                                                prepend_with_imports[source] = new Types();
                                        }

                                        if (!(parent_is[1] in prepend_with_imports)) {
                                                prepend_with_imports[parent_is[1]] = new Types();
                                        }

                                        existing[checking[0].name] = prepend_with_imports[
                                                source
                                        ].add(sub_type);

                                        existing[parent_function] = prepend_with_imports[
                                                parent_is[1]
                                        ].add(parent_is[0]);
                                }
                        }
                }
        }

        static #filter_info(
                {
                        instancePath,
                        instancePath_partial,
                        parentDataProperty,
                }: validate_call_argument_1_match,
                checking: ValidateCallInfo[],
        ) {
                if (undefined !== instancePath_partial) {
                        checking = checking.filter((maybe) => (
                                maybe.instancePath
                                && maybe.instancePath.includes(
                                        instancePath_partial,
                                )
                        ));
                } else if (undefined !== instancePath) {
                        checking = checking.filter((maybe) => (
                                (
                                        maybe.instancePath
                                        && 1 === maybe.instancePath.length
                                        && maybe.instancePath[0] === instancePath
                                )
                                || (
                                        maybe.instancePath === null
                                        && instancePath === null
                                )
                        ));
                }

                if (parentDataProperty) {
                        checking = checking.filter((maybe) => (
                                maybe.parentDataProperty === parentDataProperty
                        ));
                }

                return checking;
        }

        static #specify_types_from_collected_outside_in_deep_dive(
                info: {
                        [key: string]: [
                                ValidateCallInfo,
                                ...ValidateCallInfo[],
                        ],
                },
                function_name: keyof typeof info,
                sub_types: [specify_type_nested, ...specify_type_nested[]],
                existing: specify_types_instance,
                prepend_with_imports: prepend_with_imports,
        ) {
                for (const sub_type of sub_types) {
                        const [,, match_with] = sub_type;

                        const checking = this.#filter_info(
                                match_with,
                                info[function_name],
                        ).filter((maybe) => !(maybe.name in existing));

                        if (1 === checking.length) {
                                if (!(sub_type[1] in prepend_with_imports)) {
                                        prepend_with_imports[sub_type[1]] = new Types();
                                }

                                existing[checking[0].name] = prepend_with_imports[
                                        sub_type[1]
                                ].add(sub_type[0]);

                                if (4 === sub_type.length && checking[0].name in info) {
                                        this.#specify_types_from_collected_outside_in_deep_dive(
                                                info,
                                                checking[0].name,
                                                sub_type[3],
                                                existing,
                                                prepend_with_imports,
                                        );
                                }
                        } else if (checking.length > 0) {
                                throw new Error('Unexpected matches found!');
                        }
                }
        }
}

1	import type {	1✔
2	} from '@signpostmarv/js-types';	1✔
3		1✔
4	import type {	1✔
5	BinaryExpression,	1✔
6	CallExpression,	1✔
7	ElementAccessExpression,	1✔
8	Identifier,	1✔
9	Node,	1✔
10	NodeArray,	1✔
11	ObjectLiteralExpression,	1✔
12	PropertyAccessExpression,	1✔
13	PropertyAssignment,	1✔
14	ShorthandPropertyAssignment,	1✔
15	StringLiteral,	1✔
16	} from 'typescript';	1✔
17	import {	1✔
18	isBinaryExpression,	1✔
19	isCallExpression,	1✔
20	isElementAccessExpression,	1✔
21	isFunctionDeclaration,	1✔
22	isIdentifier,	1✔
23	isObjectLiteralExpression,	1✔
24	isPropertyAccessExpression,	1✔
25	isPropertyAssignment,	1✔
26	isShorthandPropertyAssignment,	1✔
27	isStringLiteral,	1✔
28	SyntaxKind,	1✔
29	} from 'typescript';	1✔
30		1✔
31	import {	1✔
32	ConditionalPreprocessor,	1✔
33	} from '../abstracts.ts';	1✔
34		1✔
35	import type {	1✔
36	Config,	1✔
37	specify_type_nested,	1✔
38	specify_type_with_nested,	1✔
39	specify_types_instance,	1✔
40	validate_call_argument_1_match,	1✔
41	} from '../types.ts';	1✔
42		1✔
43	import type {	1✔
44	prepend_with_imports,	1✔
45	} from '../TypeReferences.ts';	1✔
46	import {	1✔
47	to_string,	1✔
48	Types,	1✔
49	} from '../TypeReferences.ts';	1✔
50		1✔
51	type CandidateBinaryExpressionString = (	1✔
52	& BinaryExpression	1✔
53	& {	1✔
54	left: Identifier,	1✔
55	operatorToken: {	1✔
56	kind: SyntaxKind.PlusToken,	1✔
57	},	1✔
58	right: StringLiteral,	1✔
59	}	1✔
60	);	1✔
61		1✔
62	type CandidateBinaryExpressionStringConcat = (	1✔
63	& BinaryExpression	1✔
64	& {	1✔
65	left: CandidateBinaryExpressionString,	1✔
66	operatorToken: {	1✔
67	kind: SyntaxKind.PlusToken,	1✔
68	},	1✔
69	right: (	1✔
70	\| Identifier	1✔
71	\| PropertyAccessExpression	1✔
72	\| CallExpression	1✔
73	),	1✔
74	}	1✔
75	);	1✔
76		1✔
77	type instancePath_initializer = (	1✔
78	\| StringLiteral	1✔
79	\| CandidateBinaryExpressionString	1✔
80	\| CandidateBinaryExpressionStringConcat	1✔
81	);	1✔
82		1✔
83	type argument_1_property_instancePath = (	1✔
84	& (	1✔
85	\| ShorthandPropertyAssignment	1✔
86	\| (	1✔
87	& PropertyAssignment	1✔
88	& {	1✔
89	initializer: instancePath_initializer,	1✔
90	}	1✔
91	)	1✔
92	)	1✔
93	& {	1✔
94	name: (	1✔
95	& Identifier	1✔
96	& {	1✔
97	text: 'instancePath',	1✔
98	}	1✔
99	),	1✔
100	}	1✔
101	);	1✔
102		1✔
103	type Candidate = (	1✔
104	& CallExpression	1✔
105	& {	1✔
106	expression: (	1✔
107	& Identifier	1✔
108	& {	1✔
109	text: `validate${number}`,	1✔
110	}	1✔
111	),	1✔
112	arguments: (	1✔
113	& NodeArray<(	1✔
114	\| Identifier	1✔
115	\| PropertyAccessExpression	1✔
116	\| ObjectLiteralExpression	1✔
117	\| ElementAccessExpression	1✔
118	)>	1✔
119	& {	1✔
120	length: 2,	1✔
121	0: (	1✔
122	\| Identifier	1✔
123	\| PropertyAccessExpression	1✔
124	\| ElementAccessExpression	1✔
125	),	1✔
126	1: (	1✔
127	& ObjectLiteralExpression	1✔
128	& {	1✔
129	properties: (	1✔
130	& NodeArray<PropertyAssignment>	1✔
131	& {	1✔
132	length: 5,	1✔
133	0: argument_1_property_instancePath,	1✔
134	2: (	1✔
135	& PropertyAssignment	1✔
136	& {	1✔
137	name: (	1✔
138	& Identifier	1✔
139	& {	1✔
140	text: 'parentDataProperty',	1✔
141	}	1✔
142	),	1✔
143	initializer: (	1✔
144	\| StringLiteral	1✔
145	\| Identifier	1✔
146	),	1✔
147	}	1✔
148	),	1✔
149	}	1✔
150	),	1✔
151	}	1✔
152	),	1✔
153	}	1✔
154	),	1✔
155	}	1✔
156	);	1✔
157		1✔
158	const unique_id = Symbol('unique_id');	1✔
159		1✔
160	export type ValidateCallInfo = {	1✔
161	name: string,	1✔
162		1✔
163	// we're using null here as a placeholder for stuff we're not supporting	1✔
164	instancePath: (	1✔
165	\| null	1✔
166	\| [string]	1✔
167	\| [string \| null, ...(string \| null)[]]	1✔
168	),	1✔
169		1✔
170	parentDataProperty: string \| null,	1✔
171		1✔
172	[unique_id]: string,	1✔
173	};	1✔
174		1✔
175	export default class CollectValidateCalls extends ConditionalPreprocessor<	1✔
176	Candidate	1✔
177	> {	1✔
178	constructor(validate_calls: {	1✔
179	[key: string]: [	30✔
180	ValidateCallInfo,	30✔
181	...ValidateCallInfo[],	30✔
182	],	30✔
183	}) {	30✔
184	super(	30✔
185	(maybe): maybe is Candidate => (	30✔
186	isCallExpression(maybe)	286,051✔
187	&& isIdentifier(maybe.expression)	286,051✔
188	&& this.validate_function_name.test(maybe.expression.text)	286,051✔
189	&& 2 === maybe.arguments.length	286,051✔
190	&& (	286,051✔
191	isIdentifier(maybe.arguments[0])	73✔
192	\|\| isPropertyAccessExpression(maybe.arguments[0])	73✔
193	\|\| isElementAccessExpression(maybe.arguments[0])	73✔
194	)	73✔
195	&& isObjectLiteralExpression(maybe.arguments[1])	286,051✔
196	&& 5 === maybe.arguments[1].properties.length	286,051✔
197	&& (	286,051✔
198	(	73✔
199	isShorthandPropertyAssignment(	73✔
200	maybe.arguments[1].properties[0],	73✔
201	)	73✔
202	\|\| (	73✔
203	isPropertyAssignment(	60✔
204	maybe.arguments[1].properties[0],	60✔
205	)	60✔
206	&& this.#is_instancePath_initializer(	60✔
207	maybe.arguments[	60✔
208	1	60✔
209	].properties[	60✔
210	0	60✔
211	].initializer,	60✔
212	)	60✔
213	)	60✔
214	)	73✔
215	&& isIdentifier(	73✔
216	maybe.arguments[1].properties[0].name,	73✔
217	)	73✔
218	&& 'instancePath' === maybe.arguments[	73✔
219	1	73✔
220	].properties[	73✔
221	0	73✔
222	].name.text	73✔
223	)	73✔
224	&& (	286,051✔
225	isShorthandPropertyAssignment(	73✔
226	maybe.arguments[1].properties[2],	73✔
227	)	73✔
228	\|\| (	73✔
229	isPropertyAssignment(maybe.arguments[1].properties[2])	60✔
230	&& (	60✔
231	isStringLiteral(	60✔
232	maybe.arguments[1].properties[2].initializer,	60✔
233	)	60✔
234	\|\| isIdentifier(	60✔
235	maybe.arguments[1].properties[2].initializer,	18✔
236	)	18✔
237	)	60✔
238	)	60✔
239	)	73✔
240	&& isIdentifier(maybe.arguments[1].properties[2].name)	286,051✔
241	&& 'parentDataProperty' === (	286,051✔
242	maybe.arguments[1].properties[2].name.text	73✔
243	)	73✔
244	),	30✔
245	(node) => {	30✔
246	let checking: Node \| undefined = node.parent;	73✔
247		73✔
248	while (checking) {	73✔
249	if (	723✔
250	isFunctionDeclaration(checking)	723✔
251	&& !!checking.name	723✔
252	&& isIdentifier(checking.name)	723✔
253	&& this.validate_function_name.test(	723✔
254	checking.name.text,	73✔
255	)	73✔
256	) {	723✔
257	const called_in = checking.name.getText();	73✔
258		73✔
259	let instancePath: ValidateCallInfo['instancePath'];	73✔
260		73✔
261	if (isShorthandPropertyAssignment(	73✔
262	node.arguments[1].properties[0],	73✔
263	)) {	73✔
264	instancePath = null;	13✔
265	} else if (isStringLiteral(	73✔
266	node.arguments[1].properties[0].initializer,	60✔
267	)) {	60!
UNCOV 268	instancePath = [	×
UNCOV 269	node.arguments[	×
UNCOV 270	1	×
UNCOV 271	].properties[	×
UNCOV 272	0	×
UNCOV 273	].initializer.text,	×
UNCOV 274	];	×
275	} else {	60✔
276	// oxlint-disable-next-line @stylistic/max-len	60✔
277	instancePath = this.#unpack_CandidateBinaryExpression(	60✔
278	node.arguments[1].properties[0].initializer,	60✔
279	);	60✔
280	}	60✔
281		73✔
282	const info: Omit<	73✔
283	ValidateCallInfo,	73✔
284	typeof unique_id	73✔
285	> = {	73✔
286	name: node.expression.text,	73✔
287	instancePath,	73✔
288	parentDataProperty: (	73✔
289	(	73✔
290	isPropertyAssignment(	73✔
291	node.arguments[	73✔
292	1	73✔
293	].properties[	73✔
294	2	73✔
295	],	73✔
296	)	73✔
297	&& isStringLiteral(	73✔
298	node.arguments[	60✔
299	1	60✔
300	].properties[	60✔
301	2	60✔
302	].initializer,	60✔
303	)	60✔
304	)	73✔
305	? node.arguments[	73✔
306	1	42✔
307	].properties[	42✔
308	2	42✔
309	].initializer.text	42✔
310	: null	73✔
311	),	73✔
312	};	73✔
313		73✔
314	const with_id: ValidateCallInfo = {	73✔
315	...info,	73✔
316	[unique_id]: JSON.stringify(info),	73✔
317	};	73✔
318		73✔
319	if (!(called_in in validate_calls)) {	73✔
320	validate_calls[called_in] = [with_id];	41✔
321	} else if (!validate_calls[called_in].find((	73✔
322	maybe,	52✔
323	) => maybe[unique_id] === with_id[unique_id])) {	32✔
324	validate_calls[called_in].push(with_id);	32✔
325	}	32✔
326		73✔
327	return true;	73✔
328	}	73✔
329		650✔
330	checking = checking.parent;	650✔
331	}	650!
UNCOV 332		×
UNCOV 333	return false;	×
334	},	30✔
335	);	30✔
336	}	30✔
337		1✔
338	#is_CandidateBinaryExpressionString(	1✔
339	maybe: Node,	106✔
340	): maybe is CandidateBinaryExpressionString {	106✔
341	return (	106✔
342	isBinaryExpression(maybe)	106✔
343	&& (	106✔
344	isIdentifier(maybe.left)	88✔
345	\|\| this.#is_CandidateBinaryExpressionStringConcat(maybe.left)	88✔
346	)	88✔
347	&& SyntaxKind.PlusToken === maybe.operatorToken.kind	106✔
348	&& isStringLiteral(maybe.right)	106✔
349	);	106✔
350	}	106✔
351		1✔
352	#is_CandidateBinaryExpressionStringConcat(	1✔
353	maybe: Node,	46✔
354	): maybe is CandidateBinaryExpressionStringConcat {	46✔
355	return (	46✔
356	isBinaryExpression(maybe)	46✔
357	&& (	46✔
358	this.#is_CandidateBinaryExpressionString(maybe.left)	46✔
359	)	46✔
360	&& SyntaxKind.PlusToken === maybe.operatorToken.kind	46✔
361	&& (	46✔
362	isIdentifier(maybe.right)	28✔
363	\|\| isPropertyAccessExpression(maybe.right)	28✔
364	\|\| isCallExpression(maybe.right)	28✔
365	)	28✔
366	);	46✔
367	}	46✔
368		1✔
369	#is_instancePath_initializer(	1✔
370	maybe: Node,	60✔
371	): maybe is instancePath_initializer {	60✔
372	return (	60✔
373	isStringLiteral(maybe)	60✔
374	\|\| this.#is_CandidateBinaryExpressionString(maybe)	60✔
375	\|\| this.#is_CandidateBinaryExpressionStringConcat(maybe)	60✔
376	);	60✔
377	}	60✔
378		1✔
379	#unpack_CandidateBinaryExpression(	1✔
380	from: (	98✔
381	\| CandidateBinaryExpressionString	98✔
382	\| CandidateBinaryExpressionStringConcat	98✔
383	),	98✔
384	current: (null \| string)[] = [],	98✔
385	): [	98✔
386	(string \| null),	98✔
387	...(string \| null)[],	98✔
388	] {	98✔
389	if (isIdentifier(from.left)) {	98✔
390	return [	60✔
391	null,	60✔
392	(	60✔
393	isStringLiteral(from.right)	60✔
394	? from.right.text	60✔
395	: null	60!
396	),	60✔
397	...current,	60✔
398	];	60✔
399	}	60✔
400		38✔
401	return this.#unpack_CandidateBinaryExpression(from.left, [null]);	38✔
402	}	98✔
403		1✔
404	static specify_types_from_collected(	1✔
405	info: {	7✔
406	[key: string]: [	7✔
407	ValidateCallInfo,	7✔
408	...ValidateCallInfo[],	7✔
409	],	7✔
410	},	7✔
411	config: Partial<Config>,	7✔
412	existing: specify_types_instance,	7✔
413	prepend_with_imports: prepend_with_imports,	7✔
414	) {	7✔
415	this.#specify_types_from_collected_inside_out(	7✔
416	info,	7✔
417	config,	7✔
418	existing,	7✔
419	prepend_with_imports,	7✔
420	);	7✔
421	this.#specify_types_from_collected_outside_in(	7✔
422	info,	7✔
423	config,	7✔
424	existing,	7✔
425	prepend_with_imports,	7✔
426	);	7✔
427	}	7✔
428		1✔
429	static #specify_types_from_collected_outside_in(	1✔
430	info: {	7✔
431	[key: string]: [	7✔
432	ValidateCallInfo,	7✔
433	...ValidateCallInfo[],	7✔
434	],	7✔
435	},	7✔
436	config: Partial<Config>,	7✔
437	existing: specify_types_instance,	7✔
438	prepend_with_imports: prepend_with_imports,	7✔
439	) {	7✔
440	const configurable = Object.entries(config.specify_types \|\| {})	7!
441	.filter((maybe): maybe is [	7✔
442	string,	8✔
443	specify_type_with_nested,	8✔
444	] => 3 === maybe[1].length)	7✔
445	.map(([key, not_object]): [	7✔
446	string,	1✔
447	[	1✔
448	ReturnType<(typeof Types)['toObject']>,	1✔
449	(typeof not_object)[1],	1✔
450	(typeof not_object)[2],	1✔
451	string,	1✔
452	],	1✔
453	] => {	1✔
454	const as_object = Types.toObject(not_object[0]);	1✔
455		1✔
456	return [	1✔
457	key,	1✔
458	[	1✔
459	as_object,	1✔
460	not_object[1],	1✔
461	not_object[2],	1✔
462	to_string(as_object),	1✔
463	],	1✔
464	];	1✔
465	});	7✔
466		7✔
467	if (configurable.length < 1) {	7✔
468	return;	6✔
469	}	6✔
470		1✔
471	const existing_entries = Object.entries(existing);	1✔
472		1✔
473	for (const [	1✔
474	,	1✔
475	[	1✔
476	,,	1✔
477	sub_types,	1✔
478	as_string,	1✔
479	],	1✔
480	] of configurable) {	1✔
481	const found = existing_entries.find((maybe) => (	1✔
482	to_string(maybe[1]) === as_string	1✔
483	));	1✔
484		1✔
485	if (!found) {	1!
UNCOV 486	continue;	×
UNCOV 487	}	×
488		1✔
489	const [function_name] = found;	1✔
490		1✔
491	if (!(function_name in info)) {	1!
UNCOV 492	continue;	×
UNCOV 493	}	×
494		1✔
495	this.#specify_types_from_collected_outside_in_deep_dive(	1✔
496	info,	1✔
497	function_name,	1✔
498	sub_types,	1✔
499	existing,	1✔
500	prepend_with_imports,	1✔
501	);	1✔
502	}	1✔
503	}	7✔
504		1✔
505	static #specify_types_from_collected_inside_out(	1✔
506	info: {	7✔
507	[key: string]: [	7✔
508	ValidateCallInfo,	7✔
509	...ValidateCallInfo[],	7✔
510	],	7✔
511	},	7✔
512	config: Partial<Config>,	7✔
513	existing: specify_types_instance,	7✔
514	prepend_with_imports: prepend_with_imports,	7✔
515	) {	7✔
516	const configurable = config.specify_types_by_inside_out_match \|\| [];	7✔
517		7✔
518	if (configurable.length < 1) {	7✔
519	return;	6✔
520	}	6✔
521		1✔
522	const info_entries = Object.entries(info);	1✔
523		1✔
524	for (const [	1✔
525	sub_type,	1✔
526	source,	1✔
527	match_with,	1✔
528	parent_is,	1✔
529	] of configurable) {	1✔
530	for (const [parent_function, has_calls] of info_entries) {	1✔
531	const checking = this.#filter_info(	7✔
532	match_with,	7✔
533	has_calls,	7✔
534	);	7✔
535		7✔
536	if (1 === checking.length) {	7✔
537	if (!(source in prepend_with_imports)) {	1!
UNCOV 538	prepend_with_imports[source] = new Types();	×
UNCOV 539	}	×
540		1✔
541	if (!(parent_is[1] in prepend_with_imports)) {	1!
UNCOV 542	prepend_with_imports[parent_is[1]] = new Types();	×
UNCOV 543	}	×
544		1✔
545	existing[checking[0].name] = prepend_with_imports[	1✔
546	source	1✔
547	].add(sub_type);	1✔
548		1✔
549	existing[parent_function] = prepend_with_imports[	1✔
550	parent_is[1]	1✔
551	].add(parent_is[0]);	1✔
552	}	1✔
553	}	7✔
554	}	1✔
555	}	7✔
556		1✔
557	static #filter_info(	1✔
558	{	15✔
559	instancePath,	15✔
560	instancePath_partial,	15✔
561	parentDataProperty,	15✔
562	}: validate_call_argument_1_match,	15✔
563	checking: ValidateCallInfo[],	15✔
564	) {	15✔
565	if (undefined !== instancePath_partial) {	15✔
566	checking = checking.filter((maybe) => (	14✔
567	maybe.instancePath	33✔
568	&& maybe.instancePath.includes(	33✔
569	instancePath_partial,	31✔
570	)	31✔
571	));	14✔
572	} else if (undefined !== instancePath) {	15✔
573	checking = checking.filter((maybe) => (	1✔
574	(	2✔
575	maybe.instancePath	2✔
576	&& 1 === maybe.instancePath.length	2!
577	&& maybe.instancePath[0] === instancePath	2!
578	)	2✔
579	\|\| (	2✔
580	maybe.instancePath === null	2✔
581	&& instancePath === null	2✔
582	)	2✔
583	));	1✔
584	}	1✔
585		15✔
586	if (parentDataProperty) {	15✔
587	checking = checking.filter((maybe) => (	11✔
588	maybe.parentDataProperty === parentDataProperty	5✔
589	));	11✔
590	}	11✔
591		15✔
592	return checking;	15✔
593	}	15✔
594		1✔
595	static #specify_types_from_collected_outside_in_deep_dive(	1✔
596	info: {	5✔
597	[key: string]: [	5✔
598	ValidateCallInfo,	5✔
599	...ValidateCallInfo[],	5✔
600	],	5✔
601	},	5✔
602	function_name: keyof typeof info,	5✔
603	sub_types: [specify_type_nested, ...specify_type_nested[]],	5✔
604	existing: specify_types_instance,	5✔
605	prepend_with_imports: prepend_with_imports,	5✔
606	) {	5✔
607	for (const sub_type of sub_types) {	5✔
608	const [,, match_with] = sub_type;	8✔
609		8✔
610	const checking = this.#filter_info(	8✔
611	match_with,	8✔
612	info[function_name],	8✔
613	).filter((maybe) => !(maybe.name in existing));	8✔
614		8✔
615	if (1 === checking.length) {	8✔
616	if (!(sub_type[1] in prepend_with_imports)) {	8!
UNCOV 617	prepend_with_imports[sub_type[1]] = new Types();	×
UNCOV 618	}	×
619		8✔
620	existing[checking[0].name] = prepend_with_imports[	8✔
621	sub_type[1]	8✔
622	].add(sub_type[0]);	8✔
623		8✔
624	if (4 === sub_type.length && checking[0].name in info) {	8✔
625	this.#specify_types_from_collected_outside_in_deep_dive(	4✔
626	info,	4✔
627	checking[0].name,	4✔
628	sub_type[3],	4✔
629	existing,	4✔
630	prepend_with_imports,	4✔
631	);	4✔
632	}	4✔
633	} else if (checking.length > 0) {	8!
UNCOV 634	throw new Error('Unexpected matches found!');	×
UNCOV 635	}	×
636	}	8✔
637	}	5✔
638	}	1✔

satisfactory-dev / ajv-utilities / 25249984834

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