fix: avoid extra iterator generation

.editorconfig

@@ -0,0 +1,19 @@
+root = true
+
+[*]
+indent_style = tab
+indent_size = 2
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+max_line_length = 80
+
+[*.{yml,yaml,json}]
+indent_style = space
+indent_size = 2
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.snap]
+trim_trailing_whitespace = false

.gitattributes

@@ -0,0 +1 @@
+* text=auto

.github/workflows/test.yml

@@ -18,10 +18,14 @@ jobs:
     runs-on: ${{ matrix.os }}
 
     steps:
-      - uses: actions/checkout@v2
+      - name: Setup Git
+        if: matrix.os == 'windows-latest'
+        run: git config --global core.autocrlf input
+
+      - uses: actions/checkout@v4
 
       - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node-version }}
           cache: yarn

compile-to-definitions/index.js

@@ -30,14 +30,14 @@ const makeDefinitionsForSchema = async (absSchemaPath, schemasDir) => {
 	const filename = path.resolve(
 		root,
 		outputFolder,
-		`${path.join(directory, basename)}.d.ts`
+		`${path.join(directory, basename)}.d.ts`,
 	);
 	const schema = JSON.parse(fs.readFileSync(absSchemaPath, "utf-8"));
 	const keys = Object.keys(schema);
 	if (keys.length === 1 && keys[0] === "$ref") return;
 
 	const prettierConfig = await prettier.resolveConfig(
-		path.resolve(root, outputFolder, "result.d.ts")
+		path.resolve(root, outputFolder, "result.d.ts"),
 	);
 	const style = {
 		printWidth: prettierConfig.printWidth,
@@ -56,7 +56,7 @@ const makeDefinitionsForSchema = async (absSchemaPath, schemasDir) => {
 		(ts) => {
 			ts = ts.replace(
 				/\s+\*\s+\* This interface was referenced by `.+`'s JSON-Schema\s+\* via the `definition` ".+"\./g,
-				""
+				"",
 			);
 			let normalizedContent = "";
 			try {
@@ -70,14 +70,14 @@ const makeDefinitionsForSchema = async (absSchemaPath, schemasDir) => {
 					fs.mkdirSync(path.dirname(filename), { recursive: true });
 					fs.writeFileSync(filename, ts, "utf-8");
 					console.error(
-						`declarations/${relPath.replace(/\\/g, "/")}.d.ts updated`
+						`declarations/${relPath.replace(/\\/g, "/")}.d.ts updated`,
 					);
 				} else {
 					console.error(
 						`declarations/${relPath.replace(
 							/\\/g,
-							"/"
-						)}.d.ts need to be updated`
+							"/",
+						)}.d.ts need to be updated`,
 					);
 					process.exitCode = 1;
 				}
@@ -86,7 +86,7 @@ const makeDefinitionsForSchema = async (absSchemaPath, schemasDir) => {
 		(err) => {
 			console.error(err);
 			process.exitCode = 1;
-		}
+		},
 	);
 };
 
@@ -113,7 +113,7 @@ const preprocessSchema = (schema, root = schema, path = []) => {
 				const result = resolvePath(root, property.$ref);
 				if (!result) {
 					throw new Error(
-						`Unable to resolve "$ref": "${property.$ref}" in ${path.join("/")}`
+						`Unable to resolve "$ref": "${property.$ref}" in ${path.join("/")}`,
 					);
 				}
 				schema.properties[key] = {
@@ -167,7 +167,7 @@ const preprocessSchema = (schema, root = schema, path = []) => {
 			implementedNames.push(/\/([^\/]+)$/.exec(impl)[1]);
 		}
 		const propEntries = Object.entries(schema.properties).filter(
-			([name]) => !implementedProps.has(name)
+			([name]) => !implementedProps.has(name),
 		);
 		if (propEntries.length > 0) {
 			const key =

declarations.d.ts

@@ -1,12 +1,12 @@
 import * as ts from "typescript";
 declare module "typescript" {
 	export function getDeclarationModifierFlagsFromSymbol(
-		s: ts.Symbol
+		s: ts.Symbol,
 	): ts.ModifierFlags;
 	export function signatureHasRestParameter(signature: ts.Signature): boolean;
 	interface Symbol {
 		type?: ts.Type;
-		parent: Symbol | undefined
+		parent: Symbol | undefined;
 	}
 	interface Declaration {
 		expression?: ts.Expression;

format-file-header/index.js

@@ -45,7 +45,8 @@ const execToArray = (content, regexp) => {
 const schema = [
 	{
 		title: "license comment",
-		regexp: /\/\*\n\s*MIT License http:\/\/www\.opensource\.org\/licenses\/mit-license\.php\n\s*(?:(Authors? .+)\n)?\s*\*\/\n/g,
+		regexp:
+			/\/\*\n\s*MIT License http:\/\/www\.opensource\.org\/licenses\/mit-license\.php\n\s*(?:(Authors? .+)\n)?\s*\*\/\n/g,
 		updateMessage: "update the license comment",
 		update(content, author) {
 			return (
@@ -82,12 +83,13 @@ const schema = [
 	},
 	{
 		title: "imports",
-		regexp: /(const (\{\s+\w+(?::\s+\w+)?(,\s+\w+(?::\s+\w+)?)*\s+\}|\w+) = (\/\*\* @type \{TODO\} \*\/\s\()?require\("[^"]+"\)\)?(\.\w+)*;\n)+\n/g,
+		regexp:
+			/(const (\{\s+\w+(?::\s+\w+)?(,\s+\w+(?::\s+\w+)?)*\s+\}|\w+) = (\/\*\* @type \{TODO\} \*\/\s\()?require\("[^"]+"\)\)?(\.\w+)*;\n)+\n/g,
 		updateMessage: "sort imports alphabetically",
 		update(content) {
 			const items = execToArray(
 				content,
-				/const (?:\{\s+\w+(?::\s+\w+)?(?:,\s+\w+(?::\s+\w+)?)*\s+\}|\w+) = (?:\/\*\* @type \{TODO\} \*\/\s\()?require\("([^"]+)"\)\)?((?:\.\w+)*);\n/g
+				/const (?:\{\s+\w+(?::\s+\w+)?(?:,\s+\w+(?::\s+\w+)?)*\s+\}|\w+) = (?:\/\*\* @type \{TODO\} \*\/\s\()?require\("([^"]+)"\)\)?((?:\.\w+)*);\n/g,
 			);
 			items.sort(sortImport);
 			return items.map((item) => item.content).join("") + "\n";
@@ -97,12 +99,13 @@ const schema = [
 	},
 	{
 		title: "type imports",
-		regexp: /(\/\*\* (?:@template \w+ )*@typedef \{(?:typeof )?import\("[^"]+"\)(\.\w+)*(?:<(?:(?:\w\.)*\w+, )*(?:\w\.)*\w+>)?\} \w+(?:<(?:(?:\w\.)*\w+, )*(?:\w\.)*\w+>)? \*\/\n)+\n/g,
+		regexp:
+			/(\/\*\* (?:@template \w+ )*@typedef \{(?:typeof )?import\("[^"]+"\)(\.\w+)*(?:<(?:(?:\w\.)*\w+, )*(?:\w\.)*\w+>)?\} \w+(?:<(?:(?:\w\.)*\w+, )*(?:\w\.)*\w+>)? \*\/\n)+\n/g,
 		updateMessage: "sort type imports alphabetically",
 		update(content) {
 			const items = execToArray(
 				content,
-				/\/\*\* (?:@template \w+ )*@typedef \{(?:typeof )?import\("([^"]+)"\)((?:\.\w+)*(?:<(?:(?:\w\.)*\w+, )*(?:\w\.)*\w+>)?)\} \w+(?:<(?:(?:\w\.)*\w+, )*(?:\w\.)*\w+>)? \*\/\n/g
+				/\/\*\* (?:@template \w+ )*@typedef \{(?:typeof )?import\("([^"]+)"\)((?:\.\w+)*(?:<(?:(?:\w\.)*\w+, )*(?:\w\.)*\w+>)?)\} \w+(?:<(?:(?:\w\.)*\w+, )*(?:\w\.)*\w+>)? \*\/\n/g,
 			);
 			items.sort(sortImport);
 			return items.map((item) => item.content).join("") + "\n";
@@ -139,7 +142,7 @@ for (const filePath of allFiles) {
 		}
 		if (match.index !== pos) {
 			console.log(
-				`${filePath}: Unexpected code at ${pos}-${match.index}, expected ${current.title}`
+				`${filePath}: Unexpected code at ${pos}-${match.index}, expected ${current.title}`,
 			);
 			process.exitCode = 1;
 			pos = match.index;
@@ -181,12 +184,12 @@ for (const filePath of allFiles) {
 	}
 
 	const matches = content.match(
-		/makeSerializable\(\s*[^,]+,\s*"webpack\/lib\/[^"]+"\s*(?:,[^)]+)?\)/g
+		/makeSerializable\(\s*[^,]+,\s*"webpack\/lib\/[^"]+"\s*(?:,[^)]+)?\)/g,
 	);
 	if (matches) {
 		for (const match of matches) {
 			const str = /makeSerializable\(\s*[^,]+,\s*"webpack\/lib\/([^"]+)"/.exec(
-				match
+				match,
 			)[1];
 			allSerializables.add(str);
 		}
@@ -195,13 +198,13 @@ for (const filePath of allFiles) {
 
 // Check if internalSerializables.js includes all serializables in webpack
 for (const internalSerializables of allFiles.filter((file) =>
-	file.includes("internalSerializables")
+	file.includes("internalSerializables"),
 )) {
 	const content = fs.readFileSync(internalSerializables);
 	for (const serializable of allSerializables) {
 		if (!content.includes(`"../${serializable}"`)) {
 			console.log(
-				`${internalSerializables}: must include static require to ../${serializable}`
+				`${internalSerializables}: must include static require to ../${serializable}`,
 			);
 			process.exitCode = 1;
 		}

format-schemas/index.js

@@ -12,12 +12,12 @@ const minSlashes = schemas
 	.map((p) => p.split(/[\\/]/).length)
 	.reduce((a, b) => Math.min(a, b), Infinity);
 const baseSchemaPaths = schemas.filter(
-	(p) => p.split(/[\\/]/).length === minSlashes
+	(p) => p.split(/[\\/]/).length === minSlashes,
 );
 const baseDefinitions = new Map();
 for (const baseSchemaPath of baseSchemaPaths) {
 	for (const [name, schema] of Object.entries(
-		require(baseSchemaPath).definitions
+		require(baseSchemaPath).definitions,
 	)) {
 		baseDefinitions.set(name, schema);
 	}
@@ -131,15 +131,15 @@ const processJson = processSchema.bind(null, {
 										...json,
 										tsType: tsType.replace(
 											/\.\.\//g,
-											context.importPrefix + "../"
+											context.importPrefix + "../",
 										),
 									};
 								}
 								return json;
 							},
 						},
 						baseDef,
-						{}
+						{},
 					);
 					json.definitions[key] = baseDef;
 				}
@@ -151,21 +151,21 @@ const processJson = processSchema.bind(null, {
 			for (const impl of [].concat(json.implements)) {
 				if (!impl.startsWith(prefix)) {
 					console.warn(
-						`"implements": "${impl}" -> should start with "${prefix}"`
+						`"implements": "${impl}" -> should start with "${prefix}"`,
 					);
 					continue;
 				}
 				const name = impl.slice(prefix.length);
 				const referencedSchema = context.definitions[name];
 				if (!referencedSchema) {
 					console.warn(
-						`"implements": "${impl}" -> referenced schema not found`
+						`"implements": "${impl}" -> referenced schema not found`,
 					);
 					continue;
 				}
 				if (typeof referencedSchema.properties !== "object") {
 					console.warn(
-						`"implements": "${impl}" -> referenced schema has no properties`
+						`"implements": "${impl}" -> referenced schema has no properties`,
 					);
 					continue;
 				}