create-typescript-app 2.63.2 → 2.65.0

package/dist/blocks/blockVSCode.mjs

@@ -0,0 +1,59 @@
+import { base } from "../base.mjs";
+import { blockDevelopmentDocs } from "./blockDevelopmentDocs.mjs";
+import { getPrimaryBin } from "./bin/getPrimaryBin.mjs";
+import { z } from "zod";
+import sortKeys from "sort-keys";
+//#region src/blocks/blockVSCode.ts
+const blockVSCode = base.createBlock({
+	about: { name: "VS Code" },
+	addons: {
+		debuggers: z.array(z.intersection(z.record(z.string(), z.unknown()), z.object({ name: z.string() }))).optional(),
+		extensions: z.array(z.string()).optional(),
+		settings: z.record(z.string(), z.unknown()).default({}),
+		tasks: z.array(z.intersection(z.object({ detail: z.string() }), z.record(z.string(), z.unknown()))).optional()
+	},
+	produce({ addons, options }) {
+		const { debuggers, extensions, settings, tasks } = addons;
+		const primaryBin = getPrimaryBin(options.bin, options.repository);
+		return {
+			addons: [blockDevelopmentDocs({
+				hints: [`> This repository includes a list of suggested VS Code extensions.`, `> It's a good idea to use [VS Code](https://code.visualstudio.com) and accept its suggestion to install them, as they'll help with development.`],
+				sections: {
+					Building: { innerSections: primaryBin ? [{
+						contents: `
+This repository includes a [VS Code launch configuration](https://code.visualstudio.com/docs/editor/debugging) for debugging.
+To debug a \`bin\` app, add a breakpoint to your code, then run _Debug Program_ from the VS Code Debug panel (or press F5).
+VS Code will automatically run the \`build\` task in the background before running \`${primaryBin}\`.
+`,
+						heading: "Built App Debugging"
+					}] : [] },
+					Testing: { innerSections: [{
+						contents: `
+This repository includes a [VS Code launch configuration](https://code.visualstudio.com/docs/editor/debugging) for debugging unit tests.
+To launch it, open a test file, then run _Debug Current Test File_ from the VS Code Debug panel (or press F5).
+`,
+						heading: "Debugging Tests"
+					}] }
+				}
+			})],
+			files: { ".vscode": {
+				"extensions.json": extensions?.length ? JSON.stringify({ recommendations: [...extensions].sort() }) : void 0,
+				"launch.json": debuggers?.length ? JSON.stringify({
+					configurations: [...debuggers].sort((a, b) => a.name.localeCompare(b.name)),
+					version: "0.2.0"
+				}) : void 0,
+				"settings.json": JSON.stringify(sortKeys({
+					"editor.formatOnSave": true,
+					"editor.rulers": [80],
+					...settings
+				})),
+				"tasks.json": tasks?.length ? JSON.stringify({
+					tasks: tasks.sort((a, b) => a.detail.localeCompare(b.detail)),
+					version: "2.0.0"
+				}) : void 0
+			} }
+		};
+	}
+});
+//#endregion
+export { blockVSCode };

package/dist/blocks/blockVitest.d.mts

@@ -0,0 +1,90 @@
+//#region src/blocks/blockVitest.d.ts
+declare const blockVitest: import("bingo-stratum").BlockWithAddons<{
+  exclude: string[];
+  actionSteps: ({
+    with?: Record<string, string> | undefined;
+    env?: Record<string, string> | undefined;
+    if?: string | undefined;
+  } & ({
+    run: string;
+  } | {
+    uses: string;
+  }))[];
+  coverage: {
+    exclude?: string[] | undefined;
+    include?: string[] | undefined;
+  };
+  flags: string[];
+  environment?: string | undefined;
+}, {
+  access: "public" | "restricted";
+  description: string;
+  directory: string;
+  documentation: {
+    readme: {
+      additional?: string | undefined;
+      explainer?: string | undefined;
+      footnotes?: string | undefined;
+      usage?: string | undefined;
+    };
+    development?: string | undefined;
+  };
+  email: string | {
+    github: string;
+    npm: string;
+  };
+  title: string;
+  node: {
+    minimum: string;
+    pinned?: string | undefined;
+  };
+  owner: string;
+  repository: string;
+  type?: "commonjs" | "module" | undefined;
+  author?: string | undefined;
+  bin?: string | Record<string, string> | undefined;
+  bundle?: boolean | undefined;
+  codecovToken?: boolean | undefined;
+  contributors?: {
+    avatar_url: string;
+    contributions: string[];
+    login: string;
+    name: string;
+    profile: string;
+  }[] | undefined;
+  emoji?: string | undefined;
+  existingLabels?: {
+    name: string;
+    description: string;
+    color: string;
+  }[] | undefined;
+  funding?: string | undefined;
+  guide?: {
+    href: string;
+    title: string;
+  } | undefined;
+  keywords?: string[] | undefined;
+  logo?: {
+    alt: string;
+    src: string;
+    height?: number | undefined;
+    width?: number | undefined;
+  } | undefined;
+  packageData?: {
+    dependencies?: Record<string, string> | undefined;
+    devDependencies?: Record<string, string> | undefined;
+    peerDependencies?: Record<string, string> | undefined;
+    peerDependenciesMeta?: Record<string, unknown> | undefined;
+    scripts?: Record<string, string | undefined> | undefined;
+  } | undefined;
+  pnpm?: string | undefined;
+  rulesetId?: string | undefined;
+  version?: string | undefined;
+  words?: string[] | undefined;
+  workflowsVersions?: Record<string, Record<string, {
+    pinned?: boolean | undefined;
+    hash?: string | undefined;
+  }>> | undefined;
+}>;
+//#endregion
+export { blockVitest };

package/dist/blocks/blockVitest.mjs

@@ -0,0 +1,208 @@
+import { zActionStep } from "./actions/steps.mjs";
+import { getPackageDependencies } from "../data/packageData.mjs";
+import { base } from "../base.mjs";
+import { blockRemoveFiles } from "./blockRemoveFiles.mjs";
+import { blockGitHubActionsCI } from "./blockGitHubActionsCI.mjs";
+import { blockPackageJson } from "./blockPackageJson.mjs";
+import { blockDevelopmentDocs } from "./blockDevelopmentDocs.mjs";
+import { blockRemoveWorkflows } from "./blockRemoveWorkflows.mjs";
+import { blockVSCode } from "./blockVSCode.mjs";
+import { blockCSpell } from "./blockCSpell.mjs";
+import { blockRemoveDependencies } from "./blockRemoveDependencies.mjs";
+import { blockESLint } from "./blockESLint.mjs";
+import { blockExampleFiles } from "./blockExampleFiles.mjs";
+import { blockGitignore } from "./blockGitignore.mjs";
+import { blockKnip } from "./blockKnip.mjs";
+import { blockPrettier } from "./blockPrettier.mjs";
+import { intakeFileDefineConfig } from "./intake/intakeFileDefineConfig.mjs";
+import { blockTSDown } from "./blockTSDown.mjs";
+import { z } from "zod";
+//#region src/blocks/blockVitest.ts
+const zCoverage = z.object({
+	exclude: z.array(z.string()).optional(),
+	include: z.array(z.string()).optional()
+});
+const zEnvironment = z.string();
+const zExclude = z.array(z.string());
+const zTest = z.object({
+	coverage: zCoverage,
+	environment: zEnvironment,
+	exclude: zExclude
+}).partial();
+function intakeFromConfig(files) {
+	const rawData = intakeFileDefineConfig(files, ["vitest.config.ts"]);
+	if (typeof rawData?.test !== "object") return;
+	const parsedData = zTest.safeParse(rawData.test).data;
+	if (!parsedData) return;
+	return {
+		coverage: parsedData.coverage,
+		environment: parsedData.environment,
+		exclude: parsedData.exclude
+	};
+}
+const blockVitest = base.createBlock({
+	about: { name: "Vitest" },
+	addons: {
+		actionSteps: z.array(zActionStep).default([]),
+		coverage: zCoverage.default({}),
+		environment: zEnvironment.optional(),
+		exclude: zExclude.default([]),
+		flags: z.array(z.string()).default([])
+	},
+	intake({ files, options }) {
+		return {
+			...intakeFromConfig(files),
+			flags: options.packageData?.scripts?.test?.match(/^vitest (.+)/)?.[1].split(" ")
+		};
+	},
+	produce({ addons }) {
+		const { actionSteps, coverage, environment, exclude } = addons;
+		const excludeText = JSON.stringify(Array.from(/* @__PURE__ */ new Set(["node_modules", ...exclude])).sort());
+		return {
+			addons: [
+				blockCSpell({ ignorePaths: ["coverage"] }),
+				blockDevelopmentDocs({ sections: { Testing: { contents: `
+[Vitest](https://vitest.dev) is used for tests.
+You can run it locally on the command-line:
+
+\`\`\`shell
+pnpm run test
+\`\`\`
+
+Add the \`--coverage\` flag to compute test coverage and place reports in the \`coverage/\` directory:
+
+\`\`\`shell
+pnpm run test --coverage
+\`\`\`
+
+Note that [console-fail-test](https://github.com/JoshuaKGoldberg/console-fail-test) is enabled for all test runs.
+Calls to \`console.log\`, \`console.warn\`, and other console methods will cause a test to fail.
+
+
+		` } } }),
+				blockESLint({
+					extensions: [{
+						extends: ["vitest.configs.recommended"],
+						files: ["**/*.test.*"],
+						rules: [{ entries: {
+							"@typescript-eslint/no-unsafe-assignment": "off",
+							"vitest/prefer-describe-function-title": "error"
+						} }],
+						settings: { vitest: { typecheck: true } }
+					}],
+					ignores: ["coverage", "**/*.snap"],
+					imports: [{
+						source: "@vitest/eslint-plugin",
+						specifier: "vitest"
+					}]
+				}),
+				blockExampleFiles({ files: { "greet.test.ts": `import { describe, expect, it, vi } from "vitest";
+
+import { greet } from "./greet.ts";
+
+const message = "Yay, testing!";
+
+describe(greet, () => {
+	it("logs to the console once when message is provided as a string", () => {
+		const logger = vi.spyOn(console, "log").mockImplementation(() => undefined);
+
+		greet(message);
+
+		expect(logger).toHaveBeenCalledWith(message);
+		expect(logger).toHaveBeenCalledTimes(1);
+	});
+
+	it("logs to the console once when message is provided as an object", () => {
+		const logger = vi.spyOn(console, "log").mockImplementation(() => undefined);
+
+		greet({ message });
+
+		expect(logger).toHaveBeenCalledWith(message);
+		expect(logger).toHaveBeenCalledTimes(1);
+	});
+
+	it("logs once when times is not provided in an object", () => {
+		const logger = vi.fn();
+
+		greet({ logger, message });
+
+		expect(logger).toHaveBeenCalledWith(message);
+		expect(logger).toHaveBeenCalledTimes(1);
+	});
+
+	it("logs a specified number of times when times is provided", () => {
+		const logger = vi.fn();
+		const times = 7;
+
+		greet({ logger, message, times });
+
+		expect(logger).toHaveBeenCalledWith(message);
+		expect(logger).toHaveBeenCalledTimes(7);
+	});
+});
+` } }),
+				blockGitignore({ ignores: ["/coverage"] }),
+				blockGitHubActionsCI({ jobs: [{
+					name: "Test",
+					steps: [{ run: "pnpm run test --coverage" }, ...actionSteps]
+				}] }),
+				blockKnip({ entry: ["src/**/*.test.*"] }),
+				blockPackageJson({ properties: {
+					devDependencies: getPackageDependencies("@vitest/coverage-v8", "@vitest/eslint-plugin", "console-fail-test", "vitest"),
+					scripts: { test: `vitest ${addons.flags.join(" ")}`.trim() }
+				} }),
+				blockPrettier({ ignores: ["/coverage"] }),
+				blockTSDown({ entry: ["!src/**/*.test.*"] }),
+				blockVSCode({
+					debuggers: [{
+						args: ["run", "${relativeFile}"],
+						autoAttachChildProcesses: true,
+						console: "integratedTerminal",
+						name: "Debug Current Test File",
+						program: "${workspaceRoot}/node_modules/vitest/vitest.mjs",
+						request: "launch",
+						skipFiles: ["<node_internals>/**", "**/node_modules/**"],
+						smartStep: true,
+						type: "node"
+					}],
+					extensions: ["vitest.explorer"]
+				})
+			],
+			files: { "vitest.config.ts": `import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		clearMocks: true,
+		coverage: {
+			${coverage.exclude?.length ? `exclude: ${JSON.stringify(coverage.exclude)},
+			` : ""}include: ${JSON.stringify(coverage.include)},
+			reporter: ["html", "lcov"],
+		},${environment ? `
+		environment: "${environment}",` : ""}
+		exclude: [${excludeText.slice(1, excludeText.length - 1)}],
+		setupFiles: ["console-fail-test/setup"],
+	},
+});
+	` }
+		};
+	},
+	transition() {
+		return { addons: [
+			blockRemoveDependencies({ dependencies: [
+				"@vitest/coverage-istanbul",
+				"eslint-plugin-jest",
+				"eslint-plugin-mocha",
+				"eslint-plugin-vitest",
+				"jest mocha"
+			] }),
+			blockRemoveFiles({ files: [
+				".mocha*",
+				"jest.config.*",
+				"vitest.config.{c,j,m}*"
+			] }),
+			blockRemoveWorkflows({ workflows: ["test"] })
+		] };
+	}
+});
+//#endregion
+export { blockVitest };

package/dist/blocks/blockWebExt.d.mts

@@ -0,0 +1,73 @@
+//#region src/blocks/blockWebExt.d.ts
+declare const blockWebExt: import("bingo-stratum").BlockWithoutAddons<{
+  access: "public" | "restricted";
+  description: string;
+  directory: string;
+  documentation: {
+    readme: {
+      additional?: string | undefined;
+      explainer?: string | undefined;
+      footnotes?: string | undefined;
+      usage?: string | undefined;
+    };
+    development?: string | undefined;
+  };
+  email: string | {
+    github: string;
+    npm: string;
+  };
+  title: string;
+  node: {
+    minimum: string;
+    pinned?: string | undefined;
+  };
+  owner: string;
+  repository: string;
+  type?: "commonjs" | "module" | undefined;
+  author?: string | undefined;
+  bin?: string | Record<string, string> | undefined;
+  bundle?: boolean | undefined;
+  codecovToken?: boolean | undefined;
+  contributors?: {
+    avatar_url: string;
+    contributions: string[];
+    login: string;
+    name: string;
+    profile: string;
+  }[] | undefined;
+  emoji?: string | undefined;
+  existingLabels?: {
+    name: string;
+    description: string;
+    color: string;
+  }[] | undefined;
+  funding?: string | undefined;
+  guide?: {
+    href: string;
+    title: string;
+  } | undefined;
+  keywords?: string[] | undefined;
+  logo?: {
+    alt: string;
+    src: string;
+    height?: number | undefined;
+    width?: number | undefined;
+  } | undefined;
+  packageData?: {
+    dependencies?: Record<string, string> | undefined;
+    devDependencies?: Record<string, string> | undefined;
+    peerDependencies?: Record<string, string> | undefined;
+    peerDependenciesMeta?: Record<string, unknown> | undefined;
+    scripts?: Record<string, string | undefined> | undefined;
+  } | undefined;
+  pnpm?: string | undefined;
+  rulesetId?: string | undefined;
+  version?: string | undefined;
+  words?: string[] | undefined;
+  workflowsVersions?: Record<string, Record<string, {
+    pinned?: boolean | undefined;
+    hash?: string | undefined;
+  }>> | undefined;
+}>;
+//#endregion
+export { blockWebExt };

package/dist/blocks/blockWebExt.mjs

@@ -0,0 +1,104 @@
+import { base } from "../base.mjs";
+import { blockGitHubActionsCI } from "./blockGitHubActionsCI.mjs";
+import { blockPackageJson } from "./blockPackageJson.mjs";
+import { blockDevelopmentDocs } from "./blockDevelopmentDocs.mjs";
+import { blockCSpell } from "./blockCSpell.mjs";
+import { blockESLint } from "./blockESLint.mjs";
+import { blockGitignore } from "./blockGitignore.mjs";
+import { blockPrettier } from "./blockPrettier.mjs";
+import { blockVitest } from "./blockVitest.mjs";
+//#region src/blocks/blockWebExt.ts
+const blockWebExt = base.createBlock({
+	about: { name: "Web-ext" },
+	produce() {
+		return { addons: [
+			blockCSpell({ ignorePaths: ["assets", "lib"] }),
+			blockDevelopmentDocs({ sections: {
+				Building: {
+					contents: `
+Run [ESBuild](https://esbuild.github.io) locally to build source files:
+
+\`\`\`shell
+pnpm dev
+\`\`\`
+
+Add \`--watch\` to run the builder in a watch mode that continuously re-builds as you save files:
+
+\`\`\`shell
+pnpm dev --watch
+\`\`\`
+`,
+					innerSections: [
+						{
+							contents: `
+Follow Google Chrome's _[Load an unpacked extension](https://developer.chrome.com/docs/extensions/mv3/getstarted/#unpacked)_ guide to load this repository's directory as an extension locally.
+
+> ♻️ Remember to reload the extension in \`chrome://extensions\` whenever you make changes locally!
+`,
+							heading: "Local Development with Chrome"
+						},
+						{
+							contents: `
+Follow Firefox's _[Temporary installation in Firefox](https://extensionworkshop.com/documentation/develop/temporary-installation-in-firefox/)_ guide to load this repository's directory as an extension locally.
+
+You'll then need to authorize the extension to run on <https://github.com>:
+
+1. Find and select the _Extensions_ icon in the top right of Firefox
+2. Select the _"Manage Extension"_ gear icon next to _Refined Saved Replies_
+3. Select the _"Always Allow on github.com"_ option
+
+> ♻️ Remember to reload the extension in \`about:debugging#/runtime/this-firefox\` whenever you make changes locally!
+`,
+							heading: "Local Development with Firefox"
+						},
+						{
+							contents: `
+Run [\`web-ext\`](https://extensionworkshop.com) to build a production-ready \`.zip\` under \`./web-ext-artifacts/\`:
+
+\`\`\`shell
+pnpm build
+\`\`\`
+
+Then upload that \`./web-ext-artifacts/refined_saved_replies-*.zip\` file to:
+
+- [Chrome Web Store Developer Dashboard](https://chrome.google.com/webstore/devconsole)
+- [Firefox Add-ons Developer Hub](https://addons.mozilla.org/en-US/developers/addon/submit/distribution)
+`,
+							heading: "Production Builds"
+						}
+					]
+				},
+				Linting: { contents: { items: [`- \`pnpm lint:web-ext\` ([web-ext](https://extensionworkshop.com)): Lints browser extension metadata after \`pnpm dev\` creates local files`] } }
+			} }),
+			blockESLint({ ignores: ["lib"] }),
+			blockGitHubActionsCI({ jobs: [{
+				name: "Build",
+				steps: [{ run: "pnpm build" }]
+			}, {
+				name: "Lint Web-ext",
+				steps: [{ run: "pnpm dev" }, { run: "pnpm lint:web-ext" }]
+			}] }),
+			blockGitignore({ ignores: [
+				"*.zip",
+				"/lib",
+				"web-ext-artifacts"
+			] }),
+			blockPackageJson({ properties: {
+				devDependencies: {
+					esbuild: "^0.25.0",
+					"web-ext": "^8.3.0"
+				},
+				files: ["lib/"],
+				scripts: {
+					build: "web-ext build --overwrite-dest",
+					dev: "esbuild src/content-script.ts --bundle --minify --outfile=lib/content-script.js --sourcemap",
+					"lint:web-ext": "web-ext lint"
+				}
+			} }),
+			blockPrettier({ ignores: ["/lib", "assets/"] }),
+			blockVitest({ exclude: ["lib"] })
+		] };
+	}
+});
+//#endregion
+export { blockWebExt };

package/dist/blocks/codecov/findCodecovStep.d.mts

@@ -0,0 +1,6 @@
+import { JobOrRunStep } from "../actions/steps.mjs";
+//#region src/blocks/codecov/findCodecovStep.d.ts
+declare const codecovTokenSecret = "${{ secrets.CODECOV_TOKEN }}";
+declare function findCodecovStep(steps: JobOrRunStep[]): JobOrRunStep | undefined;
+//#endregion
+export { codecovTokenSecret, findCodecovStep };

package/dist/blocks/codecov/findCodecovStep.mjs

@@ -0,0 +1,7 @@
+//#region src/blocks/codecov/findCodecovStep.ts
+const codecovTokenSecret = "${{ secrets.CODECOV_TOKEN }}";
+function findCodecovStep(steps) {
+	return steps.find((step) => typeof step.uses === "string" && step.uses.startsWith("codecov/codecov-action"));
+}
+//#endregion
+export { codecovTokenSecret, findCodecovStep };

package/dist/blocks/eslint/blockESLintIntake.d.mts

@@ -0,0 +1,10 @@
+//#region src/blocks/eslint/blockESLintIntake.d.ts
+declare function blockESLintIntake(sourceText: string): {
+  ignores: (string | (RegExp & string))[];
+  rules: {
+    entries: Record<string, "off" | "error" | "warn" | ["error" | "warn", unknown] | ["error" | "warn", unknown, unknown]>;
+    comment?: string | undefined;
+  }[];
+} | undefined;
+//#endregion
+export { blockESLintIntake };

package/dist/blocks/eslint/blockESLintIntake.mjs

@@ -0,0 +1,84 @@
+import { tryCatch } from "../../utils/tryCatch.mjs";
+import "../blockESLintMoreStyling.mjs";
+import { zRuleOptions } from "./schemas.mjs";
+import JSON5 from "json5";
+import { AST_NODE_TYPES, parse } from "@typescript-eslint/typescript-estree";
+//#region src/blocks/eslint/blockESLintIntake.ts
+function blockESLintIntake(sourceText) {
+	const configExport = tryCatch(() => parse(sourceText, {
+		comment: true,
+		loc: true,
+		range: true
+	}))?.body.find(nodeIsConfigExport);
+	if (!configExport) return;
+	const configArguments = configExport.declaration.arguments;
+	if (configArguments.length < 2) return;
+	const ignores = getConfigIgnores(configArguments[0]);
+	if (!ignores) return;
+	const rulesObject = getConfigRulesObject(configArguments.slice(1));
+	if (!rulesObject) return;
+	const rules = collectRulesObjectGroups(sourceText, rulesObject);
+	if (!rules) return;
+	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;
+		const name = property.key.value;
+		const { data } = zRuleOptions.safeParse(JSON5.parse(sourceText.slice(...property.value.range)));
+		return data && {
+			entry: data,
+			name
+		};
+	}
+	function collectRulesObjectGroups(sourceText, rulesObject) {
+		let previousNode;
+		let currentGroup;
+		const groups = [];
+		for (const property of rulesObject.properties) {
+			const comment = sourceText.slice((previousNode?.range[1] ?? rulesObject.range[0]) + 1, property.range[0]).replaceAll(/\/\/ ?|\t\s*/g, "").trim() || void 0;
+			if (comment === "Stylistic concerns that don't interfere with Prettier") break;
+			const rule = collectRuleFromProperty(property);
+			if (!rule) return;
+			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;
+		const rulesObject = configObject.properties[3];
+		return rulesObject.type === AST_NODE_TYPES.Property && rulesObject.value.type === AST_NODE_TYPES.ObjectExpression && rulesObject.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";
+	}
+}
+//#endregion
+export { blockESLintIntake };

package/dist/blocks/eslint/blockESLintPluginIntake.d.mts

@@ -0,0 +1,6 @@
+//#region src/blocks/eslint/blockESLintPluginIntake.d.ts
+declare function blockESLintPluginIntake(sourceText: string): {
+  configEmoji: [string, string][];
+} | undefined;
+//#endregion
+export { blockESLintPluginIntake };

package/dist/blocks/eslint/blockESLintPluginIntake.mjs

@@ -0,0 +1,27 @@
+import { tryCatch } from "../../utils/tryCatch.mjs";
+import { zConfigEmoji } from "./schemas.mjs";
+import JSON5 from "json5";
+import { AST_NODE_TYPES, parse } from "@typescript-eslint/typescript-estree";
+//#region src/blocks/eslint/blockESLintPluginIntake.ts
+function blockESLintPluginIntake(sourceText) {
+	const ast = tryCatch(() => parse(sourceText, {
+		comment: true,
+		loc: true,
+		range: true
+	}));
+	if (!ast) return;
+	const config = findConfig(ast.body);
+	if (!config) return;
+	const configEmoji = findConfigEmoji(config.properties);
+	if (!configEmoji) return;
+	const { data } = zConfigEmoji.safeParse(JSON5.parse(sourceText.slice(...configEmoji.range)));
+	return data && { configEmoji: data };
+	function findConfig(body) {
+		for (const node of body) if (node.type === AST_NODE_TYPES.VariableDeclaration && node.declarations[0].id.type === AST_NODE_TYPES.Identifier && node.declarations[0].id.name === "config" && node.declarations[0].init?.type === AST_NODE_TYPES.ObjectExpression) return node.declarations[0].init;
+	}
+	function findConfigEmoji(properties) {
+		for (const node of properties) if (node.type === AST_NODE_TYPES.Property && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "configEmoji" && node.value.type === AST_NODE_TYPES.ArrayExpression) return node.value;
+	}
+}
+//#endregion
+export { blockESLintPluginIntake };