create-typescript-app 2.63.2 → 2.65.0

package/bin/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { runTemplateCLI } from "bingo";
 
-import { template } from "../lib/index.js";
+import { template } from "../dist/index.mjs";
 
 process.exitCode = await runTemplateCLI(template);

package/dist/base.d.mts

@@ -0,0 +1,170 @@
+import { BaseOptionsFor } from "bingo-stratum";
+import { z } from "zod";
+//#region src/base.d.ts
+declare const base: import("bingo-stratum").Base<{
+  access: z.ZodUnion<[z.ZodLiteral<"public">, z.ZodLiteral<"restricted">]>;
+  author: z.ZodOptional<z.ZodString>;
+  bin: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+  bundle: z.ZodOptional<z.ZodBoolean>;
+  codecovToken: z.ZodOptional<z.ZodBoolean>;
+  contributors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    avatar_url: z.ZodString;
+    contributions: z.ZodArray<z.ZodString, "many">;
+    login: z.ZodString;
+    name: z.ZodString;
+    profile: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    avatar_url: string;
+    contributions: string[];
+    login: string;
+    name: string;
+    profile: string;
+  }, {
+    avatar_url: string;
+    contributions: string[];
+    login: string;
+    name: string;
+    profile: string;
+  }>, "many">>;
+  description: z.ZodDefault<z.ZodString>;
+  directory: z.ZodString;
+  documentation: z.ZodObject<{
+    development: z.ZodOptional<z.ZodString>;
+    readme: z.ZodObject<{
+      additional: z.ZodOptional<z.ZodString>;
+      explainer: z.ZodOptional<z.ZodString>;
+      footnotes: z.ZodOptional<z.ZodString>;
+      usage: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+      additional?: string | undefined;
+      explainer?: string | undefined;
+      footnotes?: string | undefined;
+      usage?: string | undefined;
+    }, {
+      additional?: string | undefined;
+      explainer?: string | undefined;
+      footnotes?: string | undefined;
+      usage?: string | undefined;
+    }>;
+  }, "strip", z.ZodTypeAny, {
+    readme: {
+      additional?: string | undefined;
+      explainer?: string | undefined;
+      footnotes?: string | undefined;
+      usage?: string | undefined;
+    };
+    development?: string | undefined;
+  }, {
+    readme: {
+      additional?: string | undefined;
+      explainer?: string | undefined;
+      footnotes?: string | undefined;
+      usage?: string | undefined;
+    };
+    development?: string | undefined;
+  }>;
+  email: z.ZodUnion<[z.ZodString, z.ZodObject<{
+    github: z.ZodString;
+    npm: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    github: string;
+    npm: string;
+  }, {
+    github: string;
+    npm: string;
+  }>]>;
+  emoji: z.ZodOptional<z.ZodString>;
+  existingLabels: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    color: z.ZodString;
+    description: z.ZodString;
+    name: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    color: string;
+  }, {
+    name: string;
+    description: string;
+    color: string;
+  }>, "many">>;
+  funding: z.ZodOptional<z.ZodString>;
+  guide: z.ZodOptional<z.ZodObject<{
+    href: z.ZodString;
+    title: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    href: string;
+    title: string;
+  }, {
+    href: string;
+    title: string;
+  }>>;
+  keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+  logo: z.ZodOptional<z.ZodObject<{
+    alt: z.ZodString;
+    height: z.ZodOptional<z.ZodNumber>;
+    src: z.ZodString;
+    width: z.ZodOptional<z.ZodNumber>;
+  }, "strip", z.ZodTypeAny, {
+    alt: string;
+    src: string;
+    height?: number | undefined;
+    width?: number | undefined;
+  }, {
+    alt: string;
+    src: string;
+    height?: number | undefined;
+    width?: number | undefined;
+  }>>;
+  node: z.ZodObject<{
+    minimum: z.ZodString;
+    pinned: z.ZodOptional<z.ZodString>;
+  }, "strip", z.ZodTypeAny, {
+    minimum: string;
+    pinned?: string | undefined;
+  }, {
+    minimum: string;
+    pinned?: string | undefined;
+  }>;
+  owner: z.ZodString;
+  packageData: z.ZodOptional<z.ZodObject<{
+    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    peerDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    peerDependenciesMeta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    scripts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodString>>>;
+  }, "strip", z.ZodTypeAny, {
+    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;
+  }, {
+    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;
+  }>>;
+  pnpm: z.ZodOptional<z.ZodString>;
+  repository: z.ZodString;
+  rulesetId: z.ZodOptional<z.ZodString>;
+  title: z.ZodString;
+  type: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"commonjs">, z.ZodLiteral<"module">]>>;
+  version: z.ZodOptional<z.ZodString>;
+  words: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+  workflowsVersions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+    hash: z.ZodOptional<z.ZodString>;
+    pinned: z.ZodOptional<z.ZodBoolean>;
+  }, "strip", z.ZodTypeAny, {
+    pinned?: boolean | undefined;
+    hash?: string | undefined;
+  }, {
+    pinned?: boolean | undefined;
+    hash?: string | undefined;
+  }>>>>;
+}>;
+type BaseOptions = BaseOptionsFor<typeof base> & {
+  preset?: string;
+};
+//#endregion
+export { BaseOptions, base };

package/dist/base.mjs

@@ -0,0 +1,162 @@
+import { readAccess } from "./options/readAccess.mjs";
+import { readAllContributors } from "./options/readAllContributors.mjs";
+import { readAuthor } from "./options/readAuthor.mjs";
+import { readBin } from "./options/readBin.mjs";
+import { readBundle } from "./options/readBundle.mjs";
+import { readCodecovToken } from "./options/readCodecovToken.mjs";
+import { readDescription } from "./options/readDescription.mjs";
+import { readDevelopmentDocumentation } from "./options/readDevelopmentDocumentation.mjs";
+import { readDocumentation } from "./options/readDocumentation.mjs";
+import { readEmailFromCodeOfConduct } from "./options/readEmailFromCodeOfConduct.mjs";
+import { readEmailFromGit } from "./options/readEmailFromGit.mjs";
+import { readEmailFromNpm } from "./options/readEmailFromNpm.mjs";
+import { readEmails } from "./options/readEmails.mjs";
+import { readEmoji } from "./options/readEmoji.mjs";
+import { readExistingLabels } from "./options/readExistingLabels.mjs";
+import { readFileSafe } from "./options/readFileSafe.mjs";
+import { readFunding } from "./options/readFunding.mjs";
+import { readGitDefaults } from "./options/readGitDefaults.mjs";
+import { readGuide } from "./options/readGuide.mjs";
+import { readKeywords } from "./options/readKeywords.mjs";
+import { readLogo } from "./options/readLogo.mjs";
+import { readNode } from "./options/readNode.mjs";
+import { readNpmDefaults } from "./options/readNpmDefaults.mjs";
+import { readOwner } from "./options/readOwner.mjs";
+import { readPackageAuthor } from "./options/readPackageAuthor.mjs";
+import { readPackageData } from "./options/readPackageData.mjs";
+import { readPnpm } from "./options/readPnpm.mjs";
+import { readReadmeFootnotes } from "./options/readReadmeFootnotes.mjs";
+import { readReadmeAdditional } from "./options/readReadmeAdditional.mjs";
+import { readReadmeExplainer } from "./options/readReadmeExplainer.mjs";
+import { readReadmeUsage } from "./options/readReadmeUsage.mjs";
+import { readRepository } from "./options/readRepository.mjs";
+import { readRulesetId } from "./options/readRulesetId.mjs";
+import { readTitle } from "./options/readTitle.mjs";
+import { readWords } from "./options/readWords.mjs";
+import { readWorkflowsVersions } from "./options/readWorkflowsVersions.mjs";
+import { zContributor, zDocumentation, zEmails, zWorkflowsVersions } from "./schemas.mjs";
+import { createBase } from "bingo-stratum";
+import { inputFromFile } from "input-from-file";
+import { inputFromScript } from "input-from-script";
+import lazyValue from "lazy-value";
+import { z } from "zod";
+//#region src/base.ts
+const base = createBase({
+	options: {
+		access: z.union([z.literal("public"), z.literal("restricted")]).describe("which `npm publish --access` to release npm packages with"),
+		author: z.string().optional().describe("username on npm to publish packages under"),
+		bin: z.union([z.string(), z.record(z.string())]).optional().describe("value to set in `package.json`'s `\"bin\"` property"),
+		bundle: z.boolean().optional().describe("whether to bundle build output into a single file, instead of one output file per source file"),
+		codecovToken: z.boolean().optional().describe("whether to send a `CODECOV_TOKEN` repository secret to Codecov in CI"),
+		contributors: z.array(zContributor).optional().describe("AllContributors contributors to store in .all-contributorsrc"),
+		description: z.string().default("A very lovely package. Hooray!").describe("'Sentence case.' description of the repository"),
+		directory: z.string().describe("Directory to create the repository in"),
+		documentation: zDocumentation.describe("additional docs to add to .md files"),
+		email: z.union([z.string(), zEmails]).describe("email address to be listed as the point of contact in docs and packages"),
+		emoji: z.string().optional().describe("decorative emoji to use in descriptions and docs"),
+		existingLabels: z.array(z.object({
+			color: z.string(),
+			description: z.string(),
+			name: z.string()
+		})).optional().describe("existing labels from the GitHub repository"),
+		funding: z.string().optional().describe("GitHub organization or username to mention in `funding.yaml`"),
+		guide: z.object({
+			href: z.string(),
+			title: z.string()
+		}).optional().describe("link to a contribution guide to place at the top of development docs"),
+		keywords: z.array(z.string()).optional().describe("any number of keywords to include in `package.json`"),
+		logo: z.object({
+			alt: z.string(),
+			height: z.number().optional(),
+			src: z.string(),
+			width: z.number().optional()
+		}).optional().describe("local image file and alt text to display near the top of the README.md"),
+		node: z.object({
+			minimum: z.string(),
+			pinned: z.string().optional()
+		}).describe("Node.js engine version(s) to pin and require a minimum of"),
+		owner: z.string().describe("organization or user owning the repository"),
+		packageData: z.object({
+			dependencies: z.record(z.string(), z.string()).optional(),
+			devDependencies: z.record(z.string(), z.string()).optional(),
+			peerDependencies: z.record(z.string(), z.string()).optional(),
+			peerDependenciesMeta: z.record(z.unknown()).optional(),
+			scripts: z.record(z.string(), z.string().optional()).optional()
+		}).optional().describe("additional properties to include in `package.json`"),
+		pnpm: z.string().optional().describe("pnpm version for package.json's packageManager field"),
+		repository: z.string().describe("'kebab-case' or 'PascalCase' title of the repository"),
+		rulesetId: z.string().optional().describe("GitHub branch ruleset ID for main branch protections"),
+		title: z.string().describe("'Title Case' title for the repository"),
+		type: z.union([z.literal("commonjs"), z.literal("module")]).optional().describe("package.json modules type"),
+		version: z.string().optional().describe("package version to publish as and store in `package.json`"),
+		words: z.array(z.string()).optional().describe("additional words to add to the CSpell dictionary"),
+		workflowsVersions: zWorkflowsVersions.optional().describe("existing versions of GitHub Actions workflows used")
+	},
+	prepare({ options, take }) {
+		const getAccess = lazyValue(async () => await readAccess(getPackageData));
+		const getAllContributors = lazyValue(async () => await readAllContributors(take));
+		const getAuthor = lazyValue(async () => await readAuthor(getPackageAuthor, getNpmDefaults, getGitUser, options.owner));
+		const getBin = lazyValue(async () => await readBin(getPackageData));
+		const getBundle = lazyValue(async () => await readBundle(take));
+		const getCodecovToken = lazyValue(async () => await readCodecovToken(take));
+		const getEmoji = lazyValue(async () => await readEmoji(getDescription));
+		const getDescription = lazyValue(async () => await readDescription(getPackageData, getReadme, getRepository));
+		const getDevelopmentDocumentation = lazyValue(async () => await readDevelopmentDocumentation(take));
+		const getDocumentation = lazyValue(async () => await readDocumentation(getDevelopmentDocumentation, getReadmeAdditional, getReadmeExplainer, getReadmeFootnotes, getReadmeUsage));
+		const getEmail = lazyValue(async () => await readEmails(getEmailFromCodeOfConduct, getEmailFromGit, getEmailFromNpm, getPackageAuthor));
+		const getKeywords = lazyValue(async () => await readKeywords(getPackageData));
+		const getEmailFromCodeOfConduct = lazyValue(async () => await readEmailFromCodeOfConduct(take));
+		const getEmailFromGit = lazyValue(async () => await readEmailFromGit(take));
+		const getEmailFromNpm = lazyValue(async () => await readEmailFromNpm(getNpmDefaults, getPackageAuthor));
+		const getExistingLabels = lazyValue(async () => await readExistingLabels(take, getOwner, getRepository));
+		const getFunding = lazyValue(async () => await readFunding(take));
+		const getGitDefaults = lazyValue(async () => await readGitDefaults(take));
+		const getGitUser = lazyValue(async () => await take(inputFromScript, { command: "git config user.name" }));
+		const getGuide = lazyValue(async () => await readGuide(take));
+		const getLogo = lazyValue(async () => await readLogo(getReadme));
+		const getPackageData = lazyValue(async () => await readPackageData(take));
+		const getNode = lazyValue(async () => await readNode(getNvmrc, getPackageData));
+		const getNpmDefaults = lazyValue(async () => await readNpmDefaults(getNpmWhoami));
+		const getNpmWhoami = lazyValue(async () => await take(inputFromScript, { command: "npm whoami --offline" }));
+		const getNvmrc = lazyValue(async () => await take(inputFromFile, { filePath: ".nvmrc" }));
+		const getOwner = lazyValue(async () => await readOwner(take, getGitDefaults, getPackageAuthor));
+		const getPackageAuthor = lazyValue(async () => await readPackageAuthor(getPackageData));
+		const getPnpm = lazyValue(async () => await readPnpm(getPackageData));
+		const getReadme = lazyValue(async () => await readFileSafe("README.md", ""));
+		const getReadmeAdditional = lazyValue(async () => await readReadmeAdditional(getReadme));
+		const getReadmeExplainer = lazyValue(async () => await readReadmeExplainer(getReadme));
+		const getReadmeFootnotes = lazyValue(async () => await readReadmeFootnotes(getReadme));
+		const getReadmeUsage = lazyValue(async () => await readReadmeUsage(getReadme));
+		const getRepository = lazyValue(async () => await readRepository(getGitDefaults, getPackageData, options));
+		return {
+			access: getAccess,
+			author: getAuthor,
+			bin: getBin,
+			bundle: getBundle,
+			codecovToken: getCodecovToken,
+			contributors: getAllContributors,
+			description: getDescription,
+			documentation: getDocumentation,
+			email: getEmail,
+			emoji: getEmoji,
+			existingLabels: getExistingLabels,
+			funding: getFunding,
+			guide: getGuide,
+			keywords: getKeywords,
+			logo: getLogo,
+			node: getNode,
+			owner: getOwner,
+			packageData: getPackageData,
+			pnpm: getPnpm,
+			repository: getRepository,
+			rulesetId: lazyValue(async () => await readRulesetId(take, getOwner, getRepository)),
+			title: lazyValue(async () => await readTitle(getReadme, getRepository)),
+			type: lazyValue(async () => (await getPackageData()).type),
+			version: lazyValue(async () => (await getPackageData()).version),
+			words: lazyValue(async () => await readWords(take)),
+			workflowsVersions: lazyValue(async () => await readWorkflowsVersions(take))
+		};
+	}
+});
+//#endregion
+export { base };

package/dist/blocks/actions/resolveUses.d.mts

@@ -0,0 +1,5 @@
+import { WorkflowsVersions } from "../../schemas.mjs";
+//#region src/blocks/actions/resolveUses.d.ts
+declare function resolveUses(action: string, version: string, workflowsVersions?: WorkflowsVersions): string;
+//#endregion
+export { resolveUses };

package/dist/blocks/actions/resolveUses.mjs

@@ -0,0 +1,16 @@
+import { CachedFactory } from "cached-factory";
+import semver from "semver";
+//#region src/blocks/actions/resolveUses.ts
+const semverCoercions = new CachedFactory((version) => {
+	return semver.coerce(version)?.toString() ?? "0.0.0";
+});
+function resolveUses(action, version, workflowsVersions) {
+	if (!workflowsVersions || !(action in workflowsVersions)) return `${action}@${version}`;
+	const workflowVersions = workflowsVersions[action];
+	const biggestVersion = Object.keys(workflowVersions).reduce((highestVersion, potentialVersion) => semver.gt(semverCoercions.get(potentialVersion), semverCoercions.get(highestVersion)) ? potentialVersion : highestVersion, version);
+	if (!(biggestVersion in workflowVersions)) return `${action}@${biggestVersion}`;
+	const atBiggestVersion = workflowVersions[biggestVersion];
+	return atBiggestVersion.hash ? `${action}@${atBiggestVersion.hash} # ${biggestVersion}` : `${action}@${biggestVersion}`;
+}
+//#endregion
+export { resolveUses };

package/dist/blocks/actions/steps.d.mts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { IntakeDirectory } from "bingo-fs";
+//#region src/blocks/actions/steps.d.ts
+declare const zActionStep: z.ZodIntersection<z.ZodObject<{
+  env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  if: z.ZodOptional<z.ZodString>;
+  with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+  with?: Record<string, string> | undefined;
+  env?: Record<string, string> | undefined;
+  if?: string | undefined;
+}, {
+  with?: Record<string, string> | undefined;
+  env?: Record<string, string> | undefined;
+  if?: string | undefined;
+}>, z.ZodUnion<[z.ZodObject<{
+  run: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+  run: string;
+}, {
+  run: string;
+}>, z.ZodObject<{
+  uses: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+  uses: string;
+}, {
+  uses: string;
+}>]>>;
+interface JobOrRunStep {
+  env?: Record<string, string>;
+  uses?: unknown;
+  with?: Record<string, string>;
+}
+declare function getYamlSteps(yaml: unknown, ymlPath: string[]): JobOrRunStep[] | undefined;
+declare function intakeFileYamlSteps(files: IntakeDirectory, filePath: string[], ymlPath: string[]): JobOrRunStep[] | undefined;
+//#endregion
+export { JobOrRunStep, getYamlSteps, intakeFileYamlSteps, zActionStep };

package/dist/blocks/actions/steps.mjs

@@ -0,0 +1,19 @@
+import { intakeFileAsYaml } from "../intake/intakeFileAsYaml.mjs";
+import { z } from "zod";
+import _ from "lodash";
+//#region src/blocks/actions/steps.ts
+const zActionStep = z.intersection(z.object({
+	env: z.record(z.string(), z.string()).optional(),
+	if: z.string().optional(),
+	with: z.record(z.string(), z.string()).optional()
+}), z.union([z.object({ run: z.string() }), z.object({ uses: z.string() })]));
+function getYamlSteps(yaml, ymlPath) {
+	const steps = _.get(yaml, ymlPath);
+	return Array.isArray(steps) ? steps : void 0;
+}
+function intakeFileYamlSteps(files, filePath, ymlPath) {
+	const actionYml = intakeFileAsYaml(files, filePath);
+	return actionYml ? getYamlSteps(actionYml, ymlPath) : void 0;
+}
+//#endregion
+export { getYamlSteps, intakeFileYamlSteps, zActionStep };

package/dist/blocks/bin/getPrimaryBin.d.mts

@@ -0,0 +1,4 @@
+//#region src/blocks/bin/getPrimaryBin.d.ts
+declare function getPrimaryBin(bin: Record<string, string | undefined> | string | undefined, repository: string): string | undefined;
+//#endregion
+export { getPrimaryBin };

package/dist/blocks/bin/getPrimaryBin.mjs

@@ -0,0 +1,6 @@
+//#region src/blocks/bin/getPrimaryBin.ts
+function getPrimaryBin(bin, repository) {
+	return typeof bin === "object" ? bin[repository] : bin;
+}
+//#endregion
+export { getPrimaryBin };

package/dist/blocks/blockAllContributors.d.mts

@@ -0,0 +1,73 @@
+//#region src/blocks/blockAllContributors.d.ts
+declare const blockAllContributors: 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 { blockAllContributors };

package/dist/blocks/blockAllContributors.mjs

@@ -0,0 +1,132 @@
+import { startingOwnerContributions } from "../data/contributions.mjs";
+import { base } from "../base.mjs";
+import { resolveUses } from "./actions/resolveUses.mjs";
+import { CommandPhase } from "./phases.mjs";
+import { blockRemoveFiles } from "./blockRemoveFiles.mjs";
+import { createSoloWorkflowFile } from "./files/createSoloWorkflowFile.mjs";
+import { blockREADME } from "./blockREADME.mjs";
+import { blockPrettier } from "./blockPrettier.mjs";
+import { blockRepositorySecrets } from "./blockRepositorySecrets.mjs";
+import _ from "lodash";
+//#region src/blocks/blockAllContributors.ts
+const blockAllContributors = base.createBlock({
+	about: { name: "AllContributors" },
+	produce({ options }) {
+		const contributions = options.contributors?.length;
+		const ownerContributions = Array.from(new Set([options.contributors?.find((contributor) => contributor.login.toLowerCase() === options.owner.toLowerCase())?.contributions, startingOwnerContributions].filter(Boolean).flat()));
+		return {
+			addons: [
+				blockPrettier({ ignores: ["/.all-contributorsrc"] }),
+				blockREADME({
+					badges: [{
+						alt: `👪 All Contributors: ${contributions}`,
+						comments: {
+							after: `
+<!-- ALL-CONTRIBUTORS-BADGE:END -->
+\t<!-- prettier-ignore-end -->`,
+							before: `<!-- prettier-ignore-start -->
+\t<!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
+\t`
+						},
+						href: "#contributors",
+						src: `https://img.shields.io/badge/%F0%9F%91%AA_all_contributors-${contributions}-21bb42.svg`
+					}],
+					sections: options.contributors ? [printAllContributorsTable(options.contributors)] : void 0
+				}),
+				blockRepositorySecrets({ secrets: [{
+					description: "a GitHub PAT with repo and workflow permissions",
+					name: "ACCESS_TOKEN"
+				}] })
+			],
+			files: {
+				".all-contributorsrc": JSON.stringify({
+					badgeTemplate: "	<a href=\"#contributors\" target=\"_blank\"><img alt=\"👪 All Contributors: <%= contributors.length %>\" src=\"https://img.shields.io/badge/%F0%9F%91%AA_all_contributors-<%= contributors.length %>-21bb42.svg\" /></a>",
+					commitType: "docs",
+					contributors: options.contributors ?? [],
+					contributorsPerLine: 7,
+					contributorsSortAlphabetically: true,
+					files: ["README.md"],
+					projectName: options.repository,
+					projectOwner: options.owner,
+					repoType: "github"
+				}, null, 2),
+				".github": { workflows: { "contributors.yaml": createSoloWorkflowFile({
+					name: "Contributors",
+					on: { push: { branches: ["main"] } },
+					steps: [
+						{
+							uses: resolveUses("actions/checkout", "v4", options.workflowsVersions),
+							with: { "fetch-depth": 0 }
+						},
+						{ uses: "./.github/actions/prepare" },
+						{
+							env: { GITHUB_TOKEN: "${{ secrets.ACCESS_TOKEN }}" },
+							uses: resolveUses("JoshuaKGoldberg/all-contributors-auto-action", "v0.5.0", options.workflowsVersions)
+						}
+					]
+				}) } }
+			},
+			scripts: [{
+				commands: [`pnpx all-contributors-cli@6.23.1 add ${options.owner} ${ownerContributions.join(",")}`],
+				phase: CommandPhase.Process
+			}]
+		};
+	},
+	transition() {
+		return { addons: [blockRemoveFiles({ files: [".github/workflows/contributors.yml"] })] };
+	}
+});
+function printAllContributorsTable(contributors) {
+	return [
+		`## Contributors`,
+		``,
+		`<!-- spellchecker: disable -->`,
+		`<!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->`,
+		`<!-- prettier-ignore-start -->`,
+		`<table>`,
+		`  <tbody>`,
+		`    <tr>`,
+		..._.sortBy(contributors, "name").flatMap((contributor, i) => {
+			const row = printContributorCell(contributor);
+			return i && i % 7 === 0 ? [
+				`    </tr>`,
+				`    <tr>`,
+				row
+			] : [row];
+		}),
+		`    </tr>`,
+		`  </tbody>`,
+		`</table>`,
+		``,
+		`<!-- prettier-ignore-end -->`,
+		``,
+		`<!-- ALL-CONTRIBUTORS-LIST:END -->`,
+		`<!-- spellchecker: enable -->`
+	].join("\n");
+}
+function printContributorCell(contributor) {
+	return [
+		`      <td align="center" valign="top" width="14.28%">`,
+		`<a href="${contributor.profile}">`,
+		`<img src="${contributor.avatar_url}?s=100" width="100px;" alt="${contributor.name}"/>`,
+		`<br />`,
+		`<sub><b>${contributor.name}</b></sub></a><br />`,
+		contributor.contributions.map((contribution) => {
+			switch (contribution) {
+				case "bug": return `<a href="https://github.com/JoshuaKGoldberg/create-typescript-app/issues?q=author%3A${contributor.login}" title="Bug reports">🐛</a>`;
+				case "code": return `<a href="https://github.com/JoshuaKGoldberg/create-typescript-app/commits?author=${contributor.login}" title="Code">💻</a>`;
+				case "design": return `<a href="#design-${contributor.login}" title="Design">🎨</a>`;
+				case "doc": return `<a href="https://github.com/JoshuaKGoldberg/create-typescript-app/commits?author=${contributor.login}" title="Documentation">📖</a>`;
+				case "ideas": return `<a href="#ideas-${contributor.login}" title="Ideas, Planning, & Feedback">🤔</a>`;
+				case "infra": return `<a href="#infra-${contributor.login}" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a>`;
+				case "maintenance": return `<a href="#maintenance-${contributor.login}" title="Maintenance">🚧</a>`;
+				case "review": return `<a href="https://github.com/JoshuaKGoldberg/create-typescript-app/pulls?q=is%3Apr+reviewed-by%3A${contributor.login}" title="Reviewed Pull Requests">👀</a>`;
+				case "test": return `<a href="https://github.com/JoshuaKGoldberg/create-typescript-app/commits?author=${contributor.login}" title="Tests">⚠️</a>`;
+				case "tool": return `<a href="#tool-${contributor.login}" title="Tools">🔧</a>`;
+			}
+		}).join(" "),
+		`</td>`
+	].join("");
+}
+//#endregion
+export { blockAllContributors };