create-typescript-app 2.33.0 → 2.34.1

package/lib/blocks/blockESLint.js

@@ -10,45 +10,14 @@ import { blockRemoveDependencies } from "./blockRemoveDependencies.js";
 import { blockRemoveFiles } from "./blockRemoveFiles.js";
 import { blockRemoveWorkflows } from "./blockRemoveWorkflows.js";
 import { blockVSCode } from "./blockVSCode.js";
+import { blockESLintIntake } from "./eslint/blockESLintIntake.js";
+import {
+  zExtension,
+  zExtensionRules,
+  zPackageImport
+} from "./eslint/schemas.js";
+import { intakeFile } from "./intake/intakeFile.js";
 import { CommandPhase } from "./phases.js";
-const zRuleOptions = z.union([
-  z.literal("error"),
-  z.literal("off"),
-  z.literal("warn"),
-  z.union([
-    z.tuple([z.union([z.literal("error"), z.literal("warn")]), z.unknown()]),
-    z.tuple([
-      z.union([z.literal("error"), z.literal("warn")]),
-      z.unknown(),
-      z.unknown()
-    ])
-  ])
-]);
-const zExtensionRuleGroup = z.object({
-  comment: z.string().optional(),
-  entries: z.record(z.string(), zRuleOptions)
-});
-const zExtensionRules = z.union([
-  z.record(z.string(), zRuleOptions),
-  z.array(zExtensionRuleGroup)
-]);
-const zExtension = z.object({
-  extends: z.array(z.string()).optional(),
-  files: z.array(z.string()).optional(),
-  languageOptions: z.unknown().optional(),
-  linterOptions: z.unknown().optional(),
-  plugins: z.record(z.string(), z.string()).optional(),
-  rules: zExtensionRules.optional(),
-  settings: z.record(z.string(), z.unknown()).optional()
-});
-const zPackageImport = z.object({
-  source: z.union([
-    z.string(),
-    z.object({ packageName: z.string(), version: z.string() })
-  ]),
-  specifier: z.string(),
-  types: z.boolean().optional()
-});
 const blockESLint = base.createBlock({
   about: {
     name: "ESLint"
@@ -62,6 +31,12 @@ const blockESLint = base.createBlock({
     rules: zExtensionRules.optional(),
     settings: z.record(z.string(), z.unknown()).optional()
   },
+  intake({ files }) {
+    const eslintConfigRaw = intakeFile(files, [
+      ["eslint.config.js", "eslint.config.mjs"]
+    ]);
+    return eslintConfigRaw ? blockESLintIntake(eslintConfigRaw[0]) : void 0;
+  },
   produce({ addons, options }) {
     const { explanations, extensions, ignores, imports, rules, settings } = addons;
     const [configFileName, fileExtensions] = options.type === "commonjs" ? ["eslint.config.mjs", "js,mjs,ts"] : ["eslint.config.js", "js,ts"];

package/lib/blocks/blockESLintMoreStyling.d.ts

@@ -1,5 +1,6 @@
 import * as bingo_stratum from 'bingo-stratum';
 
+declare const stylisticComment = "Stylistic concerns that don't interfere with Prettier";
 declare const blockESLintMoreStyling: bingo_stratum.BlockWithoutAddons<{
     access: "public" | "restricted";
     description: string;
@@ -69,4 +70,4 @@ declare const blockESLintMoreStyling: bingo_stratum.BlockWithoutAddons<{
     }>> | undefined;
 }>;
 
-export { blockESLintMoreStyling };
+export { blockESLintMoreStyling, stylisticComment };

package/lib/blocks/blockESLintMoreStyling.js

@@ -1,5 +1,6 @@
 import { base } from "../base.js";
 import { blockESLint } from "./blockESLint.js";
+const stylisticComment = "Stylistic concerns that don't interfere with Prettier";
 const blockESLintMoreStyling = base.createBlock({
   about: {
     name: "ESLint More Styling"
@@ -10,7 +11,7 @@ const blockESLintMoreStyling = base.createBlock({
         blockESLint({
           rules: [
             {
-              comment: "Stylistic concerns that don't interfere with Prettier",
+              comment: stylisticComment,
               entries: {
                 "logical-assignment-operators": [
                   "error",
@@ -29,5 +30,6 @@ const blockESLintMoreStyling = base.createBlock({
   }
 });
 export {
-  blockESLintMoreStyling
+  blockESLintMoreStyling,
+  stylisticComment
 };

package/lib/blocks/eslint/blockESLintIntake.d.ts

@@ -0,0 +1,9 @@
+declare function blockESLintIntake(sourceText: string): {
+    ignores: string[];
+    rules: {
+        entries: Record<string, "off" | "error" | "warn" | ["error" | "warn", unknown] | ["error" | "warn", unknown, unknown]>;
+        comment?: string | undefined;
+    }[];
+} | undefined;
+
+export { blockESLintIntake };

package/lib/blocks/eslint/blockESLintIntake.js

@@ -0,0 +1,116 @@
+import {
+  AST_NODE_TYPES,
+  parse as parseAST
+} from "@typescript-eslint/typescript-estree";
+import JSON5 from "json5";
+import { tryCatch } from "../../utils/tryCatch.js";
+import { stylisticComment } from "../blockESLintMoreStyling.js";
+import { zRuleOptions } from "./schemas.js";
+function blockESLintIntake(sourceText) {
+  const ast = tryCatch(
+    () => parseAST(sourceText, {
+      comment: true,
+      loc: true,
+      range: true
+    })
+  );
+  const configExport = ast?.body.find(nodeIsConfigExport);
+  if (!configExport) {
+    return void 0;
+  }
+  const configArguments = configExport.declaration.arguments;
+  if (configArguments.length < 2) {
+    return void 0;
+  }
+  const ignores = getConfigIgnores(configArguments[0]);
+  if (!ignores) {
+    return void 0;
+  }
+  const rulesObject = getConfigRulesObject(configArguments.slice(1));
+  if (!rulesObject) {
+    return void 0;
+  }
+  const rules = collectRulesObjectGroups(sourceText, rulesObject);
+  if (!rules) {
+    return void 0;
+  }
+  return { ignores, rules };
+  function areArraysEqual(a, b) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function collectRuleFromProperty(property) {
+    if (property.type !== AST_NODE_TYPES.Property || property.key.type !== AST_NODE_TYPES.Literal || typeof property.key.value !== "string") {
+      return void 0;
+    }
+    const name = property.key.value;
+    const { data } = zRuleOptions.safeParse(
+      JSON5.parse(sourceText.slice(...property.value.range))
+    );
+    return data && { entry: data, name };
+  }
+  function collectRulesObjectGroups(sourceText2, rulesObject2) {
+    let previousNode;
+    let currentGroup;
+    const groups = [];
+    for (const property of rulesObject2.properties) {
+      const precedingText = sourceText2.slice(
+        (previousNode?.range[1] ?? rulesObject2.range[0]) + 1,
+        property.range[0]
+      );
+      const comment = precedingText.replaceAll(/\/\/|\n/g, "").trim() || void 0;
+      if (comment === stylisticComment) {
+        break;
+      }
+      const rule = collectRuleFromProperty(property);
+      if (!rule) {
+        return void 0;
+      }
+      if (!currentGroup || comment) {
+        currentGroup = { comment, entries: {} };
+        groups.push(currentGroup);
+      }
+      currentGroup.entries[rule.name] = rule.entry;
+      previousNode = property;
+    }
+    return groups;
+  }
+  function getConfigIgnores(node) {
+    return node.type === AST_NODE_TYPES.ObjectExpression && node.properties.length === 1 && node.properties[0].type === AST_NODE_TYPES.Property && node.properties[0].key.type === AST_NODE_TYPES.Identifier && node.properties[0].key.name === "ignores" && node.properties[0].value.type === AST_NODE_TYPES.ArrayExpression && node.properties[0].value.elements.every(
+      (element) => element?.type === AST_NODE_TYPES.Literal && typeof element.value === "string"
+    ) && node.properties[0].value.elements.map(
+      (element) => element.value
+    );
+  }
+  function getConfigRulesObject(nodes) {
+    const configObject = nodes.find(
+      (node) => node.type === AST_NODE_TYPES.ObjectExpression && areArraysEqual(
+        node.properties.map(
+          (property) => property.type === AST_NODE_TYPES.Property && property.key.type === AST_NODE_TYPES.Identifier ? property.key.name : void 0
+        ),
+        ["extends", "files", "languageOptions", "rules", "settings"]
+      )
+    );
+    if (!configObject) {
+      return void 0;
+    }
+    const rulesObject2 = configObject.properties[3];
+    return rulesObject2.type === AST_NODE_TYPES.Property && rulesObject2.value.type === AST_NODE_TYPES.ObjectExpression && rulesObject2.value;
+  }
+  function nodeIsConfigExport(node) {
+    return node.type === AST_NODE_TYPES.ExportDefaultDeclaration && node.declaration.type === AST_NODE_TYPES.CallExpression && nodeIsConfigFunction(node.declaration.callee);
+  }
+  function nodeIsConfigFunction(node) {
+    return node.type === AST_NODE_TYPES.MemberExpression && node.object.type === AST_NODE_TYPES.Identifier && node.object.name === "tseslint" && node.property.type === AST_NODE_TYPES.Identifier && node.property.name === "config";
+  }
+}
+export {
+  blockESLintIntake
+};

package/lib/blocks/eslint/schemas.d.ts

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+
+declare const zRuleOptions: z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"off">, z.ZodLiteral<"warn">, z.ZodTuple<[z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"warn">]>, z.ZodUnknown], null>, z.ZodTuple<[z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"warn">]>, z.ZodUnknown, z.ZodUnknown], null>]>;
+type RuleOptions = z.infer<typeof zRuleOptions>;
+declare const zExtensionRuleGroup: z.ZodObject<{
+    comment: z.ZodOptional<z.ZodString>;
+    entries: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"off">, z.ZodLiteral<"warn">, z.ZodTuple<[z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"warn">]>, z.ZodUnknown], null>, z.ZodTuple<[z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"warn">]>, z.ZodUnknown, z.ZodUnknown], null>]>>;
+}, "strip", z.ZodTypeAny, {
+    entries: Record<string, "off" | "error" | "warn" | ["error" | "warn", unknown] | ["error" | "warn", unknown, unknown]>;
+    comment?: string | undefined;
+}, {
+    entries: Record<string, "off" | "error" | "warn" | ["error" | "warn", unknown] | ["error" | "warn", unknown, unknown]>;
+    comment?: string | undefined;
+}>;
+type ExtensionRuleGroup = z.infer<typeof zExtensionRuleGroup>;
+declare const zExtensionRules: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"off">, z.ZodLiteral<"warn">, z.ZodTuple<[z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"warn">]>, z.ZodUnknown], null>, z.ZodTuple<[z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"warn">]>, z.ZodUnknown, z.ZodUnknown], null>]>>, z.ZodArray<z.ZodObject<{
+    comment: z.ZodOptional<z.ZodString>;
+    entries: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"off">, z.ZodLiteral<"warn">, z.ZodTuple<[z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"warn">]>, z.ZodUnknown], null>, z.ZodTuple<[z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"warn">]>, z.ZodUnknown, z.ZodUnknown], null>]>>;
+}, "strip", z.ZodTypeAny, {
+    entries: Record<string, "off" | "error" | "warn" | ["error" | "warn", unknown] | ["error" | "warn", unknown, unknown]>;
+    comment?: string | undefined;
+}, {
+    entries: Record<string, "off" | "error" | "warn" | ["error" | "warn", unknown] | ["error" | "warn", unknown, unknown]>;
+    comment?: string | undefined;
+}>, "many">]>;
+type ExtensionRules = z.infer<typeof zExtensionRules>;
+declare const zExtension: z.ZodObject<{
+    extends: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    languageOptions: z.ZodOptional<z.ZodUnknown>;
+    linterOptions: z.ZodOptional<z.ZodUnknown>;
+    plugins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    rules: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"off">, z.ZodLiteral<"warn">, z.ZodTuple<[z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"warn">]>, z.ZodUnknown], null>, z.ZodTuple<[z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"warn">]>, z.ZodUnknown, z.ZodUnknown], null>]>>, z.ZodArray<z.ZodObject<{
+        comment: z.ZodOptional<z.ZodString>;
+        entries: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"off">, z.ZodLiteral<"warn">, z.ZodTuple<[z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"warn">]>, z.ZodUnknown], null>, z.ZodTuple<[z.ZodUnion<[z.ZodLiteral<"error">, z.ZodLiteral<"warn">]>, z.ZodUnknown, z.ZodUnknown], null>]>>;
+    }, "strip", z.ZodTypeAny, {
+        entries: Record<string, "off" | "error" | "warn" | ["error" | "warn", unknown] | ["error" | "warn", unknown, unknown]>;
+        comment?: string | undefined;
+    }, {
+        entries: Record<string, "off" | "error" | "warn" | ["error" | "warn", unknown] | ["error" | "warn", unknown, unknown]>;
+        comment?: string | undefined;
+    }>, "many">]>>;
+    settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    files?: string[] | undefined;
+    rules?: Record<string, "off" | "error" | "warn" | ["error" | "warn", unknown] | ["error" | "warn", unknown, unknown]> | {
+        entries: Record<string, "off" | "error" | "warn" | ["error" | "warn", unknown] | ["error" | "warn", unknown, unknown]>;
+        comment?: string | undefined;
+    }[] | undefined;
+    settings?: Record<string, unknown> | undefined;
+    extends?: string[] | undefined;
+    languageOptions?: unknown;
+    linterOptions?: unknown;
+    plugins?: Record<string, string> | undefined;
+}, {
+    files?: string[] | undefined;
+    rules?: Record<string, "off" | "error" | "warn" | ["error" | "warn", unknown] | ["error" | "warn", unknown, unknown]> | {
+        entries: Record<string, "off" | "error" | "warn" | ["error" | "warn", unknown] | ["error" | "warn", unknown, unknown]>;
+        comment?: string | undefined;
+    }[] | undefined;
+    settings?: Record<string, unknown> | undefined;
+    extends?: string[] | undefined;
+    languageOptions?: unknown;
+    linterOptions?: unknown;
+    plugins?: Record<string, string> | undefined;
+}>;
+type Extension = z.infer<typeof zExtension>;
+declare const zPackageImport: z.ZodObject<{
+    source: z.ZodUnion<[z.ZodString, z.ZodObject<{
+        packageName: z.ZodString;
+        version: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        version: string;
+        packageName: string;
+    }, {
+        version: string;
+        packageName: string;
+    }>]>;
+    specifier: z.ZodString;
+    types: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    source: string | {
+        version: string;
+        packageName: string;
+    };
+    specifier: string;
+    types?: boolean | undefined;
+}, {
+    source: string | {
+        version: string;
+        packageName: string;
+    };
+    specifier: string;
+    types?: boolean | undefined;
+}>;
+
+export { type Extension, type ExtensionRuleGroup, type ExtensionRules, type RuleOptions, zExtension, zExtensionRuleGroup, zExtensionRules, zPackageImport, zRuleOptions };

package/lib/blocks/eslint/schemas.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+const zRuleOptions = z.union([
+  z.literal("error"),
+  z.literal("off"),
+  z.literal("warn"),
+  z.tuple([z.union([z.literal("error"), z.literal("warn")]), z.unknown()]),
+  z.tuple([
+    z.union([z.literal("error"), z.literal("warn")]),
+    z.unknown(),
+    z.unknown()
+  ])
+]);
+const zExtensionRuleGroup = z.object({
+  comment: z.string().optional(),
+  entries: z.record(z.string(), zRuleOptions)
+});
+const zExtensionRules = z.union([
+  z.record(z.string(), zRuleOptions),
+  z.array(zExtensionRuleGroup)
+]);
+const zExtension = z.object({
+  extends: z.array(z.string()).optional(),
+  files: z.array(z.string()).optional(),
+  languageOptions: z.unknown().optional(),
+  linterOptions: z.unknown().optional(),
+  plugins: z.record(z.string(), z.string()).optional(),
+  rules: zExtensionRules.optional(),
+  settings: z.record(z.string(), z.unknown()).optional()
+});
+const zPackageImport = z.object({
+  source: z.union([
+    z.string(),
+    z.object({ packageName: z.string(), version: z.string() })
+  ]),
+  specifier: z.string(),
+  types: z.boolean().optional()
+});
+export {
+  zExtension,
+  zExtensionRuleGroup,
+  zExtensionRules,
+  zPackageImport,
+  zRuleOptions
+};

package/lib/blocks/intake/intakeFile.d.ts

@@ -1,5 +1,5 @@
 import { IntakeDirectory, IntakeFileEntry } from 'bingo-fs';
 
-declare function intakeFile(files: IntakeDirectory, filePath: string[]): IntakeFileEntry | undefined;
+declare function intakeFile(files: IntakeDirectory, filePath: (string | string[])[]): IntakeFileEntry | undefined;
 
 export { intakeFile };

package/lib/blocks/intake/intakeFile.js

@@ -2,7 +2,14 @@ function intakeFile(files, filePath) {
   if (!filePath.length) {
     return void 0;
   }
-  const entry = files[filePath[0]];
+  const nextPathCandidates = typeof filePath[0] === "string" ? [filePath[0]] : filePath[0];
+  const nextFilePath = nextPathCandidates.find(
+    (candidate) => candidate in files
+  );
+  if (!nextFilePath) {
+    return void 0;
+  }
+  const entry = files[nextFilePath];
   if (filePath.length === 1) {
     return Array.isArray(entry) ? entry : void 0;
   }

package/lib/data/packageData.d.ts

@@ -1,5 +1,5 @@
 var name = "create-typescript-app";
-var version = "2.32.0";
+var version = "2.34.0";
 var description = "Quickstart-friendly TypeScript template with comprehensive, configurable, opinionated tooling. 🎁";
 var repository = {
 	type: "git",
@@ -33,6 +33,7 @@ var scripts = {
 	tsc: "tsc"
 };
 var dependencies = {
+	"@typescript-eslint/typescript-estree": "^8.29.1",
 	bingo: "^0.5.14",
 	"bingo-fs": "^0.5.5",
 	"bingo-stratum": "^0.5.11",

package/lib/utils/tryCatch.d.ts

@@ -0,0 +1,3 @@
+declare function tryCatch<T>(task: () => T | undefined): T | undefined;
+
+export { tryCatch };

package/lib/utils/tryCatch.js

@@ -0,0 +1,10 @@
+function tryCatch(task) {
+  try {
+    return task();
+  } catch {
+    return void 0;
+  }
+}
+export {
+  tryCatch
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "create-typescript-app",
-	"version": "2.33.0",
+	"version": "2.34.1",
 	"description": "Quickstart-friendly TypeScript template with comprehensive, configurable, opinionated tooling. 🎁",
 	"repository": {
 		"type": "git",
@@ -37,6 +37,7 @@
 		"*": "prettier --ignore-unknown --write"
 	},
 	"dependencies": {
+		"@typescript-eslint/typescript-estree": "^8.29.1",
 		"bingo": "^0.5.14",
 		"bingo-fs": "^0.5.5",
 		"bingo-stratum": "^0.5.11",