feat: rename --check-types to --[no-]types

.changeset/wise-hotels-cry.md

@@ -0,0 +1,5 @@
+---
+'sv': minor
+---
+
+feat: rename `--check-types <typescript|checkjs|none>` to `--types <ts|js>` with a `--no-types` flag

packages/cli/commands/add/index.ts

@@ -49,8 +49,8 @@ export const add = new Command('add')
 	.description('applies specified integrations into a project')
 	.argument('[integration...]', 'integrations to install')
 	.option('-C, --cwd <path>', 'path to working directory', defaultCwd)
-	.option('--no-install', 'skips installing dependencies')
-	.option('--no-preconditions', 'skips validating preconditions')
+	.option('--no-install', 'skip installing dependencies')
+	.option('--no-preconditions', 'skip validating preconditions')
 	//.option('--community [adder...]', 'community adders to install')
 	.configureHelp(common.helpConfig)
 	.action((adderArgs, opts) => {

packages/cli/commands/create.ts

@@ -15,16 +15,24 @@ import * as common from '../common.js';
 import { runAddCommand } from './add/index.ts';
 import { detectSync, type AgentName } from 'package-manager-detector';
 
-const langs = ['typescript', 'checkjs', 'none'] as const;
+const langs = ['ts', 'jsdoc'] as const;
+const langMap: Record<string, LanguageType | undefined> = {
+	ts: 'typescript',
+	jsdoc: 'checkjs',
+	false: 'none'
+};
 const templateChoices = templates.map((t) => t.name);
-const langOption = new Option('--check-types <lang>', 'add type checking').choices(langs);
+const langOption = new Option('--types <lang>', 'add type checking').choices(langs);
 const templateOption = new Option('--template <type>', 'template to scaffold').choices(
 	templateChoices
 );
 
 const ProjectPathSchema = v.string();
 const OptionsSchema = v.strictObject({
-	checkTypes: v.optional(v.picklist(langs)),
+	types: v.pipe(
+		v.optional(v.union([v.picklist(langs), v.boolean()])),
+		v.transform((lang) => langMap[String(lang)])
+	),
 	integrations: v.boolean(),
 	install: v.boolean(),
 	template: v.optional(v.picklist(templateChoices))
@@ -34,10 +42,11 @@ type Options = v.InferOutput<typeof OptionsSchema>;
 export const create = new Command('create')
 	.description('scaffolds a new SvelteKit project')
 	.argument('[path]', 'where the project will be created', process.cwd())
-	.addOption(langOption)
 	.addOption(templateOption)
-	.option('--no-integrations', 'skips interactive integration installer')
-	.option('--no-install', 'skips installing dependencies')
+	.addOption(langOption)
+	.option('--no-types')
+	.option('--no-integrations', 'skip interactive integration installer')
+	.option('--no-install', 'skip installing dependencies')
 	.configureHelp(common.helpConfig)
 	.action((projectPath, opts) => {
 		const cwd = v.parse(ProjectPathSchema, projectPath);
@@ -113,7 +122,7 @@ async function createProject(cwd: string, options: Options) {
 				});
 			},
 			language: () => {
-				if (options.checkTypes) return Promise.resolve(options.checkTypes);
+				if (options.types) return Promise.resolve(options.types);
 				return p.select<LanguageType>({
 					message: 'Add type checking with Typescript?',
 					initialValue: 'typescript',

packages/cli/common.ts

@@ -8,9 +8,52 @@ import { COMMANDS, constructCommand, resolveCommand } from 'package-manager-dete
 import type { Argument, HelpConfiguration, Option } from 'commander';
 import type { AdderWithoutExplicitArgs, Precondition } from '@sveltejs/cli-core';
 
+const NO_PREFIX = '--no-';
+let options: readonly Option[] = [];
+
+function getLongFlag(flags: string) {
+	return flags
+		.split(',')
+		.map((f) => f.trim())
+		.find((f) => f.startsWith('--'));
+}
+
 export const helpConfig: HelpConfiguration = {
 	argumentDescription: formatDescription,
-	optionDescription: formatDescription
+	optionDescription: formatDescription,
+	visibleOptions(cmd) {
+		// hack so that we can access existing options in `optionTerm`
+		options = cmd.options;
+
+		const visible = cmd.options.filter((o) => !o.hidden);
+		const show: Option[] = [];
+		// hide any `--no-` flag variants if there's an existing flag of a similar name
+		// e.g. `--types` and `--no-types` will combine into a single `--[no-]types` flag
+		for (const option of visible) {
+			const flag = getLongFlag(option.flags);
+			if (flag?.startsWith(NO_PREFIX)) {
+				const stripped = flag.slice(NO_PREFIX.length);
+				const isNoVariant = visible.some((o) => getLongFlag(o.flags)?.startsWith(`--${stripped}`));
+				if (isNoVariant) continue;
+			}
+			show.push(option);
+		}
+		return show;
+	},
+	optionTerm(option) {
+		const longFlag = getLongFlag(option.flags);
+		const flag = longFlag?.split(' ').at(0);
+		if (!flag || !longFlag) return option.flags;
+
+		// check if there's a `--no-{flag}` variant
+		const noVariant = `--no-${flag.slice(2)}`;
+		const hasVariant = options.some((o) => getLongFlag(o.flags) === noVariant);
+		if (hasVariant) {
+			return `--[no-]${longFlag.slice(2)}`;
+		}
+
+		return option.flags;
+	}
 };
 
 function formatDescription(arg: Option | Argument): string {