style: lint with prettier v3

unjs · Jul 28, 2023 · 3292277 · 3292277
1 parent 77ac9aa
commit 3292277
Show file tree

Hide file tree

Showing 15 changed files with 57 additions and 59 deletions.
diff --git a/.prettierrc b/.prettierrc
@@ -1,3 +1 @@
-{
-  "trailingComma": "es5"
-}
+{}
diff --git a/src/cli.ts b/src/cli.ts
@@ -21,7 +21,7 @@ async function main() {
     const json = JSON.stringify(schema, null, 2);
     const outfile = resolve(
       process.cwd(),
-      args.write === true ? "schema.json" : args.write
+      args.write === true ? "schema.json" : args.write,
     );
     await writeFile(outfile, json);
   } else {

diff --git a/src/generator/dts.ts b/src/generator/dts.ts
@@ -74,13 +74,13 @@ function extractTypeImports(declarations: string) {
       declarations = declarations.replace(
         new RegExp(
           `typeof import\\(['"]${source}['"]\\)(\\.${type}|\\[['"]${type}['"]\\])`,
-          "g"
+          "g",
         ),
-        alias
+        alias,
       );
     }
     imports.push(
-      `import type { ${sourceImports.join(", ")} } from '${source}'`
+      `import type { ${sourceImports.join(", ")} } from '${source}'`,
     );
   }
   return [...imports, declarations].join("\n");
@@ -104,7 +104,7 @@ export function generateTypes(schema: Schema, opts: GenerateTypesOptions = {}) {
 function _genTypes(
   schema: Schema,
   spaces: string,
-  opts: GenerateTypesOptions
+  opts: GenerateTypesOptions,
 ): string[] {
   const buff: string[] = [];
 
@@ -119,13 +119,13 @@ function _genTypes(
       buff.push(
         `${escapeKey(key)}${isRequired(schema, key, opts) ? "" : "?"}: ${
           val.tsType
-        },\n`
+        },\n`,
       );
     } else if (val.type === "object") {
       buff.push(
         `${escapeKey(key)}${isRequired(schema, key, opts) ? "" : "?"}: {`,
         ..._genTypes(val, spaces, opts),
-        "},\n"
+        "},\n",
       );
     } else {
       let type: string;
@@ -139,7 +139,7 @@ function _genTypes(
       buff.push(
         `${escapeKey(key)}${
           isRequired(schema, key, opts) ? "" : "?"
-        }: ${type},\n`
+        }: ${type},\n`,
       );
     }
   }
@@ -161,7 +161,7 @@ function _genTypes(
 
 function getTsType(
   type: TypeDescriptor | TypeDescriptor[],
-  opts: GenerateTypesOptions
+  opts: GenerateTypesOptions,
 ): string {
   if (Array.isArray(type)) {
     return (
@@ -201,13 +201,13 @@ function getTsType(
 export function genFunctionType(schema, opts: GenerateTypesOptions) {
   return `(${genFunctionArgs(schema.args, opts)}) => ${getTsType(
     schema.returns,
-    opts
+    opts,
   )}`;
 }
 
 export function genFunctionArgs(
   args: Schema["args"],
-  opts: GenerateTypesOptions
+  opts: GenerateTypesOptions,
 ) {
   return (
     args

diff --git a/src/generator/md.ts b/src/generator/md.ts
@@ -8,7 +8,7 @@ export function generateMarkdown(schema: Schema) {
 export function _generateMarkdown(
   schema: Schema,
   title: string,
-  level: string
+  level: string,
 ) {
   const lines: string[] = [];
 
@@ -24,7 +24,7 @@ export function _generateMarkdown(
 
   // Type and default
   lines.push(
-    `- **Type**: \`${schema.markdownType || schema.tsType || schema.type}\``
+    `- **Type**: \`${schema.markdownType || schema.tsType || schema.type}\``,
   );
   if ("default" in schema) {
     lines.push(`- **Default**: \`${JSON.stringify(schema.default)}\``);

diff --git a/src/loader/babel.ts b/src/loader/babel.ts
@@ -14,7 +14,7 @@ type GetCodeFn = (loc: t.SourceLocation) => string;
 
 const babelPluginUntyped: PluginItem = function (
   api: ConfigAPI,
-  options: { experimentalFunctions?: boolean }
+  options: { experimentalFunctions?: boolean },
 ) {
   api.cache.using(() => version);
 
@@ -32,7 +32,7 @@ const babelPluginUntyped: PluginItem = function (
             declaration.init.params,
             t.isBlockStatement(declaration.init.body)
               ? (declaration.init.body as t.BlockStatement)
-              : t.blockStatement([t.returnStatement(declaration.init.body)])
+              : t.blockStatement([t.returnStatement(declaration.init.body)]),
           );
           newDeclaration.returnType = declaration.init.returnType;
           p.replaceWith(newDeclaration);
@@ -43,7 +43,7 @@ const babelPluginUntyped: PluginItem = function (
           const schema = parseJSDocs(
             p.node.leadingComments
               .filter((c) => c.type === "CommentBlock")
-              .map((c) => c.value)
+              .map((c) => c.value),
           );
 
           const valueNode =
@@ -57,7 +57,7 @@ const babelPluginUntyped: PluginItem = function (
               (prop) =>
                 "key" in prop &&
                 prop.key.type === "Identifier" &&
-                prop.key.name === "$schema"
+                prop.key.name === "$schema",
             );
             if (schemaProp && "value" in schemaProp) {
               if (schemaProp.value.type === "ObjectExpression") {
@@ -70,7 +70,7 @@ const babelPluginUntyped: PluginItem = function (
             } else {
               // Object has not $schema
               valueNode.properties.unshift(
-                ...astify({ $schema: schema }).properties
+                ...astify({ $schema: schema }).properties,
               );
             }
           } else {
@@ -87,7 +87,7 @@ const babelPluginUntyped: PluginItem = function (
         const schema = parseJSDocs(
           (p.parent.leadingComments || [])
             .filter((c) => c.type === "CommentBlock")
-            .map((c) => c.value)
+            .map((c) => c.value),
         );
         schema.type = "function";
         schema.args = [];
@@ -143,16 +143,16 @@ const babelPluginUntyped: PluginItem = function (
               arg,
               mergedTypes(
                 arg,
-                inferAnnotationType(lparam.typeAnnotation, getCode)
-              )
+                inferAnnotationType(lparam.typeAnnotation, getCode),
+              ),
             );
           }
 
           // Infer type from default value
           if (param.type === "AssignmentPattern") {
             Object.assign(
               arg,
-              mergedTypes(arg, inferArgType(param.right, getCode))
+              mergedTypes(arg, inferArgType(param.right, getCode)),
             );
           }
           schema.args = schema.args || [];
@@ -198,9 +198,9 @@ const babelPluginUntyped: PluginItem = function (
             t.variableDeclaration("const", [
               t.variableDeclarator(
                 t.identifier(p.node.id.name),
-                astify({ $schema: schema })
+                astify({ $schema: schema }),
               ),
-            ])
+            ]),
           );
         }
       },
@@ -241,12 +241,12 @@ function parseJSDocs(input: string | string[]): Schema {
   };
 
   const lines: string[] = (Array.isArray(input) ? input : [input]).flatMap(
-    (c) => c.split("\n").map((l) => l.replace(/(^\s*\*+ )|([\s*]+$)/g, ""))
+    (c) => c.split("\n").map((l) => l.replace(/(^\s*\*+ )|([\s*]+$)/g, "")),
   );
 
   const firstTag = lines.findIndex((l) => l.startsWith("@"));
   const comments = clumpLines(
-    lines.slice(0, firstTag >= 0 ? firstTag : undefined)
+    lines.slice(0, firstTag >= 0 ? firstTag : undefined),
   );
 
   if (comments.length === 1) {
@@ -269,7 +269,7 @@ function parseJSDocs(input: string | string[]): Schema {
         }
         return typedefs;
       },
-      {} as Record<string, string>
+      {} as Record<string, string>,
     );
     for (const tag of tags) {
       if (tag.startsWith("@type")) {
@@ -283,7 +283,7 @@ function parseJSDocs(input: string | string[]): Schema {
           schema.markdownType = type;
           schema.tsType = schema.tsType.replace(
             new RegExp(typedefs[typedef], "g"),
-            typedef
+            typedef,
           );
         }
         continue;
@@ -317,7 +317,7 @@ function astify(val) {
   return t.objectExpression(
     Object.getOwnPropertyNames(val)
       .filter((key) => val[key] !== undefined && val[key] !== null)
-      .map((key) => t.objectProperty(t.identifier(key), astify(val[key])))
+      .map((key) => t.objectProperty(t.identifier(key), astify(val[key]))),
   );
 }
 
@@ -360,7 +360,7 @@ function inferArgType(e: t.Expression, getCode: GetCodeFn): TypeDescriptor {
 
 function inferAnnotationType(
   ann: t.Identifier["typeAnnotation"],
-  getCode: GetCodeFn
+  getCode: GetCodeFn,
 ): TypeDescriptor | null {
   if (ann.type !== "TSTypeAnnotation") {
     return null;
@@ -370,7 +370,7 @@ function inferAnnotationType(
 
 function inferTSType(
   tsType: t.TSType,
-  getCode: GetCodeFn
+  getCode: GetCodeFn,
 ): TypeDescriptor | null {
   if (tsType.type === "TSParenthesizedType") {
     return inferTSType(tsType.typeAnnotation, getCode);

diff --git a/src/loader/loader.ts b/src/loader/loader.ts
@@ -15,7 +15,7 @@ export interface LoaderOptions {
 
 export async function loadSchema(
   entryPath: string,
-  options: LoaderOptions = {}
+  options: LoaderOptions = {},
 ): Promise<Schema> {
   const _jitiRequire = jiti(
     process.cwd(),
@@ -27,7 +27,7 @@ export async function loadSchema(
           plugins: [[untypedPlugin, { experimentalFunctions: true }]],
         },
       },
-    })
+    }),
   );
 
   const resolvedEntryPath = _jitiRequire.resolve(entryPath);

diff --git a/src/schema.ts b/src/schema.ts
@@ -25,7 +25,7 @@ export interface ResolveSchemaOptions extends NormalizeSchemaOptions {}
 export async function resolveSchema(
   obj: InputObject,
   defaults?: InputObject,
-  options: ResolveSchemaOptions = {}
+  options: ResolveSchemaOptions = {},
 ): Promise<Schema> {
   const schema = await _resolveSchema(obj, "", {
     root: obj,
@@ -41,7 +41,7 @@ export async function resolveSchema(
 async function _resolveSchema(
   input: InputValue,
   id: string,
-  ctx: _ResolveCtx
+  ctx: _ResolveCtx,
 ): Promise<Schema> {
   // Check cache
   if (id in ctx.resolveCache) {
@@ -89,7 +89,7 @@ async function _resolveSchema(
       const child = (schema.properties[key] = await _resolveSchema(
         node[key],
         joinPath(id, key),
-        ctx
+        ctx,
       ));
 
       // Infer @required
@@ -143,7 +143,7 @@ export async function applyDefaults(ref: InputObject, input: InputObject) {
 
 function normalizeSchema(
   schema: Partial<Schema>,
-  options: NormalizeSchemaOptions
+  options: NormalizeSchemaOptions,
 ): asserts schema is Schema {
   if (schema.type === "array" && !("items" in schema)) {
     schema.items = {

diff --git a/src/types.ts b/src/types.ts
@@ -24,7 +24,7 @@ export type JSType =
 // eslint-disable-next-line no-use-before-define
 export type ResolveFn = (
   value: any,
-  get: (key: string) => any
+  get: (key: string) => any,
 ) => JSValue | Promise<JSValue>;
 
 export interface TypeDescriptor {

diff --git a/src/utils.ts b/src/utils.ts
@@ -103,7 +103,7 @@ export function mergedTypes(...types: TypeDescriptor[]): TypeDescriptor {
     return types[0];
   }
   const tsTypes = normalizeTypes(
-    types.flatMap((t) => t.tsType).filter(Boolean)
+    types.flatMap((t) => t.tsType).filter(Boolean),
   );
   return {
     type: normalizeTypes(types.flatMap((t) => t.type).filter(Boolean)),
@@ -162,7 +162,7 @@ export function getTypeDescriptor(type: string | JSType): TypeDescriptor {
     if (importName && firstType) {
       markdownType = markdownType.replace(
         match[0],
-        pascalCase(importName) + pascalCase(firstType)
+        pascalCase(importName) + pascalCase(firstType),
       );
     }
   }

diff --git a/test/schema.test.ts b/test/schema.test.ts
@@ -47,7 +47,7 @@ describe("resolveSchema", () => {
     const schema = await resolveSchema(
       { foo: { bar: 123 } },
       { foo: { bar: 123 } },
-      { ignoreDefaults: true }
+      { ignoreDefaults: true },
     );
 
     expect(schema).toMatchObject({

diff --git a/test/transform.test.ts b/test/transform.test.ts
@@ -432,7 +432,7 @@ function expectCodeToMatch(code: string, pattern: RegExp, expected: any) {
   expect(result).toBeDefined();
   // eslint-disable-next-line no-new-func, unicorn/new-for-builtins
   const obj = Function(
-    '"use strict";return (' + result.replace(/;$/, "") + ")"
+    '"use strict";return (' + result.replace(/;$/, "") + ")",
   )();
   expect(obj).toMatchObject(expected);
 }