style: fix

Author: alexander-akait

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;
 				}

inherit-types/index.js

@@ -74,7 +74,7 @@ for (const sourceFile of program.getSourceFiles()) {
 					) {
 						const baseDecl = findDeclarationInBaseClass(
 							node,
-							member.name.getText()
+							member.name.getText(),
 						);
 						if (baseDecl) {
 							const memberAsAny = /** @type {any} */ (member);
@@ -88,7 +88,7 @@ for (const sourceFile of program.getSourceFiles()) {
 							if (baseJsDocText) {
 								baseJsDocText = baseJsDocText.replace(
 									/\t \* @abstract\r?\n/g,
-									""
+									"",
 								);
 								if (!currentJsDocText) {
 									// add js doc
@@ -145,7 +145,7 @@ for (const sourceFile of program.getSourceFiles()) {
 				console.log(file);
 				for (const update of updates) {
 					console.log(
-						`* ${update.member} should have this JSDoc:\n\t${update.content}`
+						`* ${update.member} should have this JSDoc:\n\t${update.content}`,
 					);
 					if (update.oldContent) {
 						console.log(`instead of\n\t${update.oldContent}`);

lib/argv.js

@@ -2,7 +2,7 @@ module.exports = require("yargs")
 	.boolean("write")
 	.describe(
 		"write",
-		"Write updated files to disk, otherwise it only checks if they are correct."
+		"Write updated files to disk, otherwise it only checks if they are correct.",
 	)
 
 	.boolean("verbose")
@@ -11,12 +11,12 @@ module.exports = require("yargs")
 	.string("root")
 	.describe(
 		"root",
-		"Root repository directory (optional if calling from package.json scripts)."
+		"Root repository directory (optional if calling from package.json scripts).",
 	)
 	.default(
 		"root",
 		process.env.INIT_CWD || process.cwd(),
-		"The root directory from calling package.json or the current directory"
+		"The root directory from calling package.json or the current directory",
 	)
 
 	.string("schemas")
@@ -26,7 +26,7 @@ module.exports = require("yargs")
 	.string("declarations")
 	.describe(
 		"declarations",
-		"Output folder for declarations generated from schemas."
+		"Output folder for declarations generated from schemas.",
 	)
 	.default("declarations", "declarations")
 

lib/typescript-program.js

@@ -11,7 +11,7 @@ const parsedConfig = ts.parseJsonSourceFileConfigFileContent(
 	configJsonFile,
 	ts.sys,
 	root,
-	{ noEmit: true }
+	{ noEmit: true },
 );
 const { fileNames, options } = parsedConfig;
 

package.json

@@ -8,8 +8,11 @@
   "license": "MIT",
   "private": true,
   "scripts": {
+    "pretty-lint-base": "node node_modules/prettier/bin/prettier.cjs --cache --ignore-unknown .",
+    "pretty-lint-fix": "yarn pretty-lint-base --log-level warn --write",
+    "pretty-lint": "yarn pretty-lint-base --check",
     "test": "yarn lint",
-    "lint": "yarn special-lint && tsc",
+    "lint": "yarn special-lint && yarn pretty-lint && tsc",
     "special-lint": "node lockfile-lint"
   },
   "peerDependencies": {

precompile-schemas/index.js

@@ -43,7 +43,7 @@ ajv.addKeyword({
 	code(ctx) {
 		const { data, schema } = ctx;
 		ctx.fail(
-			_`${data}.includes("!") || (absolutePathRegExp.test(${data}) !== ${schema})`
+			_`${data}.includes("!") || (absolutePathRegExp.test(${data}) !== ${schema})`,
 		);
 	},
 });
@@ -84,8 +84,8 @@ ajv.addKeyword({
 					`Schema precompilation only supports primitive values in enum: ${JSON.stringify(
 						item,
 						null,
-						2
-					)}`
+						2,
+					)}`,
 				);
 			}
 		}
@@ -99,7 +99,7 @@ ajv.addKeyword({
 
 					return _`${data} !== ${x}`;
 				})
-				.reduce((a, b) => _`${a} && ${b}`)
+				.reduce((a, b) => _`${a} && ${b}`),
 		);
 	},
 });
@@ -163,7 +163,7 @@ const createDeclaration = (schemaPath, title, schemasDir) => {
 	const filename = path.resolve(
 		root,
 		declarations,
-		`${path.join(directory, basename)}`
+		`${path.join(directory, basename)}`,
 	);
 	const fromSchemaToDeclaration = path
 		.relative(path.dirname(schemaPath), filename)
@@ -213,12 +213,12 @@ const precompileSchema = async (schemaPath, schemasDir) => {
 		const precompiledSchemaPath = schemaPath.replace(/\.json$/, ".check.js");
 		const precompiledSchemaDeclarationPath = schemaPath.replace(
 			/\.json$/,
-			".check.d.ts"
+			".check.d.ts",
 		);
 		updateFile(precompiledSchemaPath, code);
 		updateFile(
 			precompiledSchemaDeclarationPath,
-			createDeclaration(schemaPath, title, schemasDir)
+			createDeclaration(schemaPath, title, schemasDir),
 		);
 	} catch (e) {
 		e.message += "\nduring precompilation of " + schemaPath;