create-typescript-app 2.64.0 → 2.65.0

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

@@ -0,0 +1,7 @@
+//#region src/blocks/eslint/getScriptFileExtension.d.ts
+interface ScriptFileExtensionOptions {
+  type?: "commonjs" | "module";
+}
+declare function getScriptFileExtension(options: ScriptFileExtensionOptions): "**/*.{js,mjs,ts}" | "**/*.{js,ts}";
+//#endregion
+export { ScriptFileExtensionOptions, getScriptFileExtension };

package/dist/blocks/eslint/getScriptFileExtension.mjs

@@ -0,0 +1,6 @@
+//#region src/blocks/eslint/getScriptFileExtension.ts
+function getScriptFileExtension(options) {
+	return options.type === "commonjs" ? "**/*.{js,mjs,ts}" : "**/*.{js,ts}";
+}
+//#endregion
+export { getScriptFileExtension };

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

@@ -0,0 +1,16 @@
+import { Extension } from "./schemas.mjs";
+//#region src/blocks/eslint/mergeAllExtensions.d.ts
+declare function mergeAllExtensions(...extensions: Extension[]): {
+  files: string[];
+  extends?: string[] | undefined;
+  languageOptions?: unknown;
+  linterOptions?: unknown;
+  plugins?: Record<string, 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;
+}[];
+//#endregion
+export { mergeAllExtensions };

package/dist/blocks/eslint/mergeAllExtensions.mjs

@@ -0,0 +1,46 @@
+//#region src/blocks/eslint/mergeAllExtensions.ts
+function mergeAllExtensions(...extensions) {
+	const entries = {};
+	for (const extension of extensions) {
+		const filesKey = JSON.stringify(extension.files);
+		entries[filesKey] = filesKey in entries ? mergeExtensions(entries[filesKey], extension, extension.files) : extension;
+	}
+	return Object.values(entries);
+}
+function mergeExtensions(a, b, files) {
+	return {
+		extends: Array.from(/* @__PURE__ */ new Set([...a.extends ?? [], ...b.extends ?? []])).sort(),
+		files,
+		languageOptions: (a.languageOptions ?? b.languageOptions) && {
+			...a.languageOptions ?? {},
+			...b.languageOptions ?? {}
+		},
+		linterOptions: (a.linterOptions ?? b.linterOptions) && {
+			...a.linterOptions ?? {},
+			...b.linterOptions ?? {}
+		},
+		plugins: (a.plugins ?? b.plugins) && {
+			...a.plugins,
+			...b.plugins
+		},
+		rules: mergeExtensionsRules(a.rules, b.rules),
+		settings: (a.settings ?? b.settings) && {
+			...a.settings,
+			...b.settings
+		}
+	};
+}
+function mergeExtensionsRules(a, b) {
+	if (!a || !b) return a ?? b;
+	if (Array.isArray(a)) {
+		if (Array.isArray(b)) return [...a, ...b];
+		return [...a, { entries: b }];
+	}
+	if (Array.isArray(b)) return [...b, { entries: a }];
+	return {
+		...a,
+		...b
+	};
+}
+//#endregion
+export { mergeAllExtensions };

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

@@ -0,0 +1,111 @@
+import { z } from "zod";
+//#region src/blocks/eslint/schemas.d.ts
+declare const zConfigEmoji: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>, "many">>;
+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 zRulesArray: 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 RulesArray = z.infer<typeof zRulesArray>;
+declare const zRulesRecord: 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>]>>;
+type RulesRecord = z.infer<typeof zRulesRecord>;
+declare const zExtensionRules: z.ZodUnion<[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">, 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>]>>]>;
+type ExtensionRules = z.infer<typeof zExtensionRules>;
+declare const zExtension: z.ZodObject<{
+  extends: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+  files: 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.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">, 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>]>>]>>;
+  settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+  files: string[];
+  extends?: string[] | undefined;
+  languageOptions?: unknown;
+  linterOptions?: unknown;
+  plugins?: Record<string, 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;
+}, {
+  files: string[];
+  extends?: string[] | undefined;
+  languageOptions?: unknown;
+  linterOptions?: unknown;
+  plugins?: Record<string, 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;
+}>;
+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;
+}>;
+//#endregion
+export { Extension, ExtensionRuleGroup, ExtensionRules, RuleOptions, RulesArray, RulesRecord, zConfigEmoji, zExtension, zExtensionRuleGroup, zExtensionRules, zPackageImport, zRuleOptions, zRulesArray, zRulesRecord };

package/dist/blocks/eslint/schemas.mjs

@@ -0,0 +1,40 @@
+import { z } from "zod";
+//#region src/blocks/eslint/schemas.ts
+const zConfigEmoji = z.array(z.tuple([z.string(), z.string()])).optional();
+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 zRulesArray = z.array(zExtensionRuleGroup);
+const zRulesRecord = z.record(z.string(), zRuleOptions);
+const zExtensionRules = z.union([zRulesArray, zRulesRecord]);
+const zExtension = z.object({
+	extends: z.array(z.string()).optional(),
+	files: z.array(z.string()),
+	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()
+});
+//#endregion
+export { zConfigEmoji, zExtension, zExtensionRuleGroup, zExtensionRules, zPackageImport, zRuleOptions, zRulesArray, zRulesRecord };

package/dist/blocks/files/createJobName.d.mts

@@ -0,0 +1,4 @@
+//#region src/blocks/files/createJobName.d.ts
+declare function createJobName(label: string): string;
+//#endregion
+export { createJobName };

package/dist/blocks/files/createJobName.mjs

@@ -0,0 +1,6 @@
+//#region src/blocks/files/createJobName.ts
+function createJobName(label) {
+	return label.replaceAll(/[?()]/g, "").replaceAll(" ", "_").toLowerCase();
+}
+//#endregion
+export { createJobName };

package/dist/blocks/files/createMultiWorkflowFile.d.mts

@@ -0,0 +1,24 @@
+import { WorkflowsVersions } from "../../schemas.mjs";
+//#region src/blocks/files/createMultiWorkflowFile.d.ts
+interface MultiWorkflowFileOptions {
+  jobs: MultiWorkflowJobOptions[];
+  name: string;
+  workflowsVersions: undefined | WorkflowsVersions;
+}
+interface MultiWorkflowJobOptions {
+  checkoutWith?: Record<string, string>;
+  if?: string;
+  name: string;
+  steps: MultiWorkflowJobStep[];
+}
+type MultiWorkflowJobStep = {
+  if?: string;
+} & ({
+  run: string;
+} | {
+  uses: string;
+  with?: Record<string, string>;
+});
+declare function createMultiWorkflowFile({ jobs, name, workflowsVersions }: MultiWorkflowFileOptions): string;
+//#endregion
+export { MultiWorkflowFileOptions, MultiWorkflowJobOptions, MultiWorkflowJobStep, createMultiWorkflowFile };

package/dist/blocks/files/createMultiWorkflowFile.mjs

@@ -0,0 +1,28 @@
+import { resolveUses } from "../actions/resolveUses.mjs";
+import { createJobName } from "./createJobName.mjs";
+import { formatWorkflowYaml } from "./formatWorkflowYaml.mjs";
+//#region src/blocks/files/createMultiWorkflowFile.ts
+function createMultiWorkflowFile({ jobs, name, workflowsVersions }) {
+	return formatWorkflowYaml({
+		jobs: Object.fromEntries(jobs.map((job) => [createJobName(job.name), {
+			if: job.if,
+			name: job.name,
+			"runs-on": "ubuntu-latest",
+			steps: [
+				{
+					uses: resolveUses("actions/checkout", "v4", workflowsVersions),
+					with: job.checkoutWith
+				},
+				{ uses: "./.github/actions/prepare" },
+				...job.steps
+			]
+		}])),
+		name,
+		on: {
+			pull_request: null,
+			push: { branches: ["main"] }
+		}
+	});
+}
+//#endregion
+export { createMultiWorkflowFile };

package/dist/blocks/files/createSoloWorkflowFile.d.mts

@@ -0,0 +1,64 @@
+//#region src/blocks/files/createSoloWorkflowFile.d.ts
+interface WorkflowFileConcurrency {
+  "cancel-in-progress"?: boolean;
+  group: string;
+}
+interface WorkflowFileOn {
+  discussion?: {
+    types?: string[];
+  };
+  discussion_comment?: {
+    types?: string[];
+  };
+  issue_comment?: {
+    types?: string[];
+  };
+  issues?: {
+    types?: string[];
+  };
+  pull_request?: null | string | {
+    branches?: string | string[];
+    types?: string[];
+  };
+  pull_request_review_comment?: {
+    types: string[];
+  };
+  pull_request_target?: {
+    types: string[];
+  };
+  push?: {
+    branches: string[];
+  };
+  release?: {
+    types: string[];
+  };
+  workflow_dispatch?: null | string;
+}
+interface WorkflowFileOptions {
+  concurrency?: WorkflowFileConcurrency;
+  if?: string;
+  jobName?: string;
+  name: string;
+  on?: WorkflowFileOn;
+  permissions?: WorkflowFilePermissions;
+  steps: WorkflowFileStep[];
+}
+interface WorkflowFilePermissions {
+  contents?: string;
+  discussions?: string;
+  "id-token"?: string;
+  issues?: string;
+  "pull-requests"?: string;
+}
+interface WorkflowFileStep {
+  env?: Record<string, string>;
+  id?: string;
+  if?: string;
+  name?: string;
+  run?: string;
+  uses?: string;
+  with?: Record<string, unknown>;
+}
+declare function createSoloWorkflowFile({ concurrency, jobName, name, on, permissions, ...options }: WorkflowFileOptions): string;
+//#endregion
+export { createSoloWorkflowFile };

package/dist/blocks/files/createSoloWorkflowFile.mjs

@@ -0,0 +1,19 @@
+import { createJobName } from "./createJobName.mjs";
+import { formatWorkflowYaml } from "./formatWorkflowYaml.mjs";
+//#region src/blocks/files/createSoloWorkflowFile.ts
+function createSoloWorkflowFile({ concurrency, jobName, name, on, permissions, ...options }) {
+	return formatWorkflowYaml({
+		concurrency,
+		jobs: { [createJobName(jobName ?? name)]: {
+			...options.if && { if: options.if },
+			...jobName && { name: jobName },
+			permissions,
+			"runs-on": "ubuntu-latest",
+			steps: options.steps
+		} },
+		name,
+		on
+	});
+}
+//#endregion
+export { createSoloWorkflowFile };

package/dist/blocks/files/formatIgnoreFile.d.mts

@@ -0,0 +1,4 @@
+//#region src/blocks/files/formatIgnoreFile.d.ts
+declare function formatIgnoreFile(lines: (string | undefined)[]): string;
+//#endregion
+export { formatIgnoreFile };

package/dist/blocks/files/formatIgnoreFile.mjs

@@ -0,0 +1,6 @@
+//#region src/blocks/files/formatIgnoreFile.ts
+function formatIgnoreFile(lines) {
+	return [...lines.filter(Boolean), ""].join("\n");
+}
+//#endregion
+export { formatIgnoreFile };

package/dist/blocks/files/formatWorkflowYaml.d.mts

@@ -0,0 +1,4 @@
+//#region src/blocks/files/formatWorkflowYaml.d.ts
+declare function formatWorkflowYaml(value: unknown): string;
+//#endregion
+export { formatWorkflowYaml };

package/dist/blocks/files/formatWorkflowYaml.mjs

@@ -0,0 +1,10 @@
+import { formatYaml } from "./formatYaml.mjs";
+//#region src/blocks/files/formatWorkflowYaml.ts
+function formatWorkflowYaml(value) {
+	return addBlankLinesBetweenJobs(formatYaml(value).replaceAll(/: "\\n(.+)"/g, ": |\n$1").replaceAll("\\n", "\n").replaceAll("\\t", "  "));
+}
+function addBlankLinesBetweenJobs(yaml) {
+	return yaml.replace(/(?<=^|\n)jobs:\n[\s\S]*?(?=\n\n\S|$)/, (jobs) => jobs.replaceAll(/\n(?= {2}\S)/g, "\n\n").replace("jobs:\n\n", "jobs:\n"));
+}
+//#endregion
+export { formatWorkflowYaml };

package/dist/blocks/files/formatYaml.d.mts

@@ -0,0 +1,4 @@
+//#region src/blocks/files/formatYaml.d.ts
+declare function formatYaml(value: unknown): string;
+//#endregion
+export { formatYaml };

package/dist/blocks/files/formatYaml.mjs

@@ -0,0 +1,21 @@
+import { removeUsesQuotes } from "./removeUsesQuotes.mjs";
+import { CORE_SCHEMA, dump, nullCoreTag, visit } from "js-yaml";
+//#region src/blocks/files/formatYaml.ts
+const options = {
+	lineWidth: -1,
+	schema: CORE_SCHEMA.withTags({
+		...nullCoreTag,
+		represent: () => "~"
+	}),
+	sortKeys: true,
+	transform(documents) {
+		visit(documents, (node) => {
+			if (node.kind === "scalar" && node.value.includes("\n		")) node.value = node.value.replaceAll(": |-\n", ": |\n").replaceAll("\n	  			", "").replaceAll(/\n\t\t\t\t\t\t$/g, "");
+		});
+	}
+};
+function formatYaml(value) {
+	return removeUsesQuotes(dump(value, options)).replaceAll(/\n(\S)/g, "\n\n$1");
+}
+//#endregion
+export { formatYaml };

package/dist/blocks/files/removeUsesQuotes.d.mts

@@ -0,0 +1,4 @@
+//#region src/blocks/files/removeUsesQuotes.d.ts
+declare function removeUsesQuotes(original: string): string;
+//#endregion
+export { removeUsesQuotes };

package/dist/blocks/files/removeUsesQuotes.mjs

@@ -0,0 +1,6 @@
+//#region src/blocks/files/removeUsesQuotes.ts
+function removeUsesQuotes(original) {
+	return original.replaceAll(/ uses: '.+'/gu, (line) => line.replaceAll("'", ""));
+}
+//#endregion
+export { removeUsesQuotes };

package/dist/blocks/getInstallationSuggestions.d.mts

@@ -0,0 +1,4 @@
+//#region src/blocks/getInstallationSuggestions.d.ts
+declare function getInstallationSuggestions(description: string, entries: string[], url: string): string[] | undefined;
+//#endregion
+export { getInstallationSuggestions };

package/dist/blocks/getInstallationSuggestions.mjs

@@ -0,0 +1,11 @@
+//#region src/blocks/getInstallationSuggestions.ts
+function getInstallationSuggestions(description, entries, url) {
+	return entries.length ? [[
+		`- ${description}`,
+		entries.length === 1 ? "" : "s",
+		` on ${url}:\n`,
+		entries.map((entry) => `   - ${entry}`).join("\n")
+	].join("")] : void 0;
+}
+//#endregion
+export { getInstallationSuggestions };