sv 0.12.1 → 0.12.3

package/dist/bin.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { f as program, l as from, r as detectPackageManager, u as Command } from "./package-manager-DYfxv5nk.mjs";
-import { ht as resolveCommand, t as color } from "./utils-CnfD6Z1s.mjs";
-import { a as helpConfig, i as forwardExitCode, n as add, o as name, r as create, s as version } from "./add-D8995Wsf.mjs";
+import { f as program, l as from, r as detectPackageManager, u as Command } from "./package-manager-BYzDyeam.mjs";
+import { a as helpConfig, i as forwardExitCode, n as add, o as name, r as create, s as version } from "./engine-BmcQ5Tk6.mjs";
+import { color, resolveCommand } from "@sveltejs/sv-utils";
 import process from "node:process";
 import { execSync } from "node:child_process";
 
-//#region lib/cli/check.ts
+//#region src/cli/check.ts
 const check = new Command("check").description("a CLI for checking your Svelte code").allowUnknownOption(true).allowExcessArguments(true).option("-C, --cwd <path>", "path to working directory", process.cwd()).helpOption(false).action(async (options, check$1) => {
 	const cwd$1 = options.cwd;
 	const args = check$1.args;
@@ -36,7 +36,7 @@ async function runCheck(cwd$1, args) {
 }
 
 //#endregion
-//#region lib/cli/migrate.ts
+//#region src/cli/migrate.ts
 const migrate = new Command("migrate").description("a CLI for migrating Svelte(Kit) codebases").argument("[migration]", "migration to run").option("-C, --cwd <path>", "path to working directory", process.cwd()).action(async (migration, options) => {
 	await runMigrate(options.cwd, [migration]);
 });

package/dist/engine-BZ0rj9tz.d.mts

@@ -0,0 +1,359 @@
+import { AgentName } from "@sveltejs/sv-utils";
+
+//#region src/addons/index.d.ts
+type OfficialAddons = {
+  prettier: Addon<any>;
+  eslint: Addon<any>;
+  vitest: Addon<any>;
+  playwright: Addon<any>;
+  tailwindcss: Addon<any>;
+  sveltekitAdapter: Addon<any>;
+  devtoolsJson: Addon<any>;
+  drizzle: Addon<any>;
+  betterAuth: Addon<any>;
+  mdsvex: Addon<any>;
+  paraglide: Addon<any>;
+  storybook: Addon<any>;
+  mcp: Addon<any>;
+};
+declare const officialAddons: OfficialAddons;
+//#endregion
+//#region src/core/options.d.ts
+type BooleanQuestion = {
+  type: "boolean";
+  default: boolean;
+};
+type StringQuestion = {
+  type: "string";
+  default: string;
+  validate?: (value: string | undefined) => string | Error | undefined;
+  placeholder?: string;
+};
+type NumberQuestion = {
+  type: "number";
+  default: number;
+  validate?: (value: string | undefined) => string | Error | undefined;
+  placeholder?: string;
+};
+type SelectQuestion<Value$1> = {
+  type: "select";
+  default: NoInfer<Value$1>;
+  options: Array<{
+    value: Value$1;
+    label?: string;
+    hint?: string;
+  }>;
+};
+type MultiSelectQuestion<Value$1> = {
+  type: "multiselect";
+  default: NoInfer<Value$1[]>;
+  options: Array<{
+    value: Value$1;
+    label?: string;
+    hint?: string;
+  }>;
+  required: boolean;
+};
+type BaseQuestion<Args extends OptionDefinition> = {
+  question: string;
+  group?: string;
+  /**
+  * When this condition explicitly returns `false`, the question's value will
+  * always be `undefined` and will not fallback to the specified `default` value.
+  */
+  condition?: (options: OptionValues<Args>) => boolean;
+};
+type Question<Args extends OptionDefinition = OptionDefinition> = BaseQuestion<Args> & (BooleanQuestion | StringQuestion | NumberQuestion | SelectQuestion<any> | MultiSelectQuestion<any>);
+type OptionDefinition = Record<string, Question<any>>;
+type OptionValues<Args extends OptionDefinition> = { [K in keyof Args]: Args[K] extends StringQuestion ? string : Args[K] extends BooleanQuestion ? boolean : Args[K] extends NumberQuestion ? number : Args[K] extends SelectQuestion<infer Value> ? Value : Args[K] extends MultiSelectQuestion<infer Value> ? Value[] : "ERROR: The value for this type is invalid. Ensure that the `default` value exists in `options`." };
+//#endregion
+//#region src/core/workspace.d.ts
+type WorkspaceOptions<Args extends OptionDefinition> = OptionValues<Args>;
+type Workspace = {
+  cwd: string;
+  /**
+  * Returns the dependency version declared in the package.json.
+  * This may differ from the installed version.
+  * Includes both dependencies and devDependencies.
+  * Also checks parent package.json files if called in a monorepo.
+  * @param pkg the package to check for
+  * @returns the dependency version with any leading characters such as ^ or ~ removed
+  */
+  dependencyVersion: (pkg: string) => string | undefined;
+  /** to know if the workspace is using typescript or javascript */
+  language: "ts" | "js";
+  files: {
+    viteConfig: "vite.config.js" | "vite.config.ts";
+    svelteConfig: "svelte.config.js" | "svelte.config.ts";
+    /** `${kit.routesDirectory}/layout.css` or `src/app.css` */
+    stylesheet: `${string}/layout.css` | "src/app.css";
+    package: "package.json";
+    gitignore: ".gitignore";
+    prettierignore: ".prettierignore";
+    prettierrc: ".prettierrc";
+    eslintConfig: "eslint.config.js";
+    vscodeSettings: ".vscode/settings.json";
+    vscodeExtensions: ".vscode/extensions.json";
+    /** Get the relative path between two files */
+    getRelative: ({
+      from,
+      to
+    }: {
+      from?: string;
+      to: string;
+    }) => string;
+  };
+  /** If we are in a kit project, this object will contain the lib and routes directories */
+  kit: {
+    libDirectory: string;
+    routesDirectory: string;
+  } | undefined;
+  /** The package manager used to install dependencies */
+  packageManager: AgentName;
+};
+type CreateWorkspaceOptions = {
+  cwd: string;
+  packageManager?: AgentName;
+  override?: {
+    kit?: Workspace["kit"];
+    dependencies: Record<string, string>;
+  };
+};
+declare function createWorkspace({
+  cwd,
+  packageManager,
+  override
+}: CreateWorkspaceOptions): Promise<Workspace>;
+//#endregion
+//#region src/core/config.d.ts
+type ConditionDefinition = (Workspace: Workspace) => boolean;
+type PackageDefinition = {
+  name: string;
+  version: string;
+  dev: boolean;
+  condition?: ConditionDefinition;
+};
+type Scripts = {
+  description: string;
+  args: string[];
+  stdio: "inherit" | "pipe";
+  condition?: ConditionDefinition;
+};
+type SvApi = {
+  /** Add a package to the pnpm build dependencies. */
+  pnpmBuildDependency: (pkg: string) => void;
+  /** Add a package to the dependencies. */
+  dependency: (pkg: string, version: string) => void;
+  /** Add a package to the dev dependencies. */
+  devDependency: (pkg: string, version: string) => void;
+  /** Execute a command in the workspace. */
+  execute: (args: string[], stdio: "inherit" | "pipe") => Promise<void>;
+  /** Edit a file in the workspace. (will create it if it doesn't exist) */
+  file: (path: string, edit: (content: string) => string) => void;
+};
+type Addon<Args extends OptionDefinition, Id$1 extends string = string> = {
+  id: Id$1;
+  alias?: string;
+  shortDescription?: string;
+  homepage?: string;
+  /** If true, this addon won't appear in the interactive prompt but can still be used via CLI */
+  hidden?: boolean;
+  options: Args;
+  /** Setup the addon. Will be called before the addon is run. */
+  setup?: (workspace: Workspace & {
+    /** On what official addons does this addon depend on? */
+    dependsOn: (name: keyof typeof officialAddons) => void;
+    /** Why is this addon not supported?
+    *
+    * @example
+    * if (!kit) unsupported('Requires SvelteKit');
+    */
+    unsupported: (reason: string) => void;
+    /** On what official addons does this addon run after? */
+    runsAfter: (name: keyof typeof officialAddons) => void;
+  }) => MaybePromise<void>;
+  /** Run the addon. The actual execution of the addon... Add files, edit files, etc. */
+  run: (workspace: Workspace & {
+    /** Add-on options */
+    options: WorkspaceOptions<Args>;
+    /** Api to interact with the workspace. */
+    sv: SvApi;
+    /** Cancel the addon at any time!
+    * @example
+    * return cancel('There is a problem with...');
+    */
+    cancel: (reason: string) => void;
+  }) => MaybePromise<void>;
+  /** Next steps to display after the addon is run. */
+  nextSteps?: (data: Workspace & {
+    options: WorkspaceOptions<Args>;
+  }) => string[];
+};
+/**
+* The entry point for your addon, It will hold every thing! (options, setup, run, nextSteps, ...)
+*/
+declare function defineAddon<const Id$1 extends string, Args extends OptionDefinition>(config: Addon<Args, Id$1>): Addon<Args, Id$1>;
+/**
+* Stage 1: Raw CLI input - what the user typed
+*/
+type AddonInput = {
+  readonly specifier: string;
+  readonly options: string[];
+};
+/**
+* Stage 2: Classified source - knows where addon comes from
+*/
+type AddonSource = {
+  readonly kind: "official";
+  readonly id: string;
+} | {
+  readonly kind: "file";
+  readonly path: string;
+} | {
+  readonly kind: "npm";
+  readonly packageName: string;
+  readonly npmUrl: string;
+  readonly registryUrl: string;
+  readonly tag: string;
+};
+type AddonReference = {
+  readonly specifier: string;
+  readonly options: string[];
+  readonly source: AddonSource;
+};
+/**
+* Stage 3: Code loaded - addon definition is always present
+*/
+type LoadedAddon = {
+  readonly reference: AddonReference;
+  readonly addon: AddonDefinition;
+};
+/**
+* Stage 4: Setup done - has dependency info
+*/
+type PreparedAddon = LoadedAddon & {
+  readonly setupResult: SetupResult;
+};
+/**
+* Stage 5: User configured - has answers to questions
+*/
+type ConfiguredAddon = PreparedAddon & {
+  readonly answers: OptionValues<any>;
+};
+/**
+* Stage 6: Execution result
+*/
+type AddonResult = {
+  readonly id: string;
+  readonly status: "success" | {
+    canceled: string[];
+  };
+  readonly files: string[];
+};
+/**
+* Generates an inline error hint based on the addon source
+*/
+declare function getErrorHint(source: AddonSource): string;
+type SetupResult = {
+  dependsOn: string[];
+  unsupported: string[];
+  runsAfter: string[];
+};
+type AddonDefinition<Id$1 extends string = string> = Addon<Record<string, Question<any>>, Id$1>;
+type Tests = {
+  expectProperty: (selector: string, property: string, expectedValue: string) => Promise<void>;
+  elementExists: (selector: string) => Promise<void>;
+  click: (selector: string, path?: string) => Promise<void>;
+  expectUrlPath: (path: string) => void;
+};
+type TestDefinition<Args extends OptionDefinition> = {
+  name: string;
+  run: (tests: Tests) => Promise<void>;
+  condition?: (options: OptionValues<Args>) => boolean;
+};
+type MaybePromise<T> = Promise<T> | T;
+type Verification = {
+  name: string;
+  run: () => MaybePromise<{
+    success: boolean;
+    message: string | undefined;
+  }>;
+};
+type Prettify<T> = { [K in keyof T]: T[K] } & unknown;
+type OptionBuilder<T extends OptionDefinition> = {
+  /**
+  * This type is a bit complex, but in usage, it's quite simple!
+  *
+  * The idea is to `add()` options one by one, with the key and the question.
+  *
+  * ```ts
+  *   .add('demo', {
+  *     question: 'Do you want to add a demo?',
+  *     type: 'boolean',  // string, number, select, multiselect
+  *     default: true,
+  *     // condition: (o) => o.previousOption === 'ok',
+  *   })
+  * ```
+  */
+  add<K$1 extends string, const Q extends Question<T & Record<K$1, Q>>>(key: K$1, question: Q): OptionBuilder<T & Record<K$1, Q>>;
+  /** Finalize all options of your `add-on`. */
+  build(): Prettify<T>;
+};
+/**
+* Options for an addon.
+*
+* Will be prompted to the user if there are not answered by args when calling the cli.
+*
+* ```ts
+* const options = defineAddonOptions()
+*   .add('demo', {
+*     question: `demo? ${color.optional('(a cool one!)')}`
+*     type: string | boolean | number | select | multiselect,
+*     default: true,
+*   })
+*   .build();
+* ```
+*
+* To define by args, you can do
+* ```sh
+* npx sv add <addon>=<option1>:<value1>+<option2>:<value2>
+* ```
+*/
+declare function defineAddonOptions(): OptionBuilder<{}>;
+//#endregion
+//#region src/core/engine.d.ts
+type InstallOptions<Addons extends AddonMap> = {
+  cwd: string;
+  addons: Addons;
+  options: OptionMap<Addons>;
+  packageManager?: AgentName;
+};
+type AddonMap = Record<string, Addon<any, any>>;
+type AddonById<Addons extends AddonMap, Id$1 extends string> = Extract<Addons[keyof Addons], {
+  id: Id$1;
+}>;
+type OptionMap<Addons extends AddonMap> = { [Id in Addons[keyof Addons]["id"]]: Partial<OptionValues<AddonById<Addons, Id>["options"]>> };
+declare function add<Addons extends AddonMap>({
+  addons,
+  cwd,
+  options,
+  packageManager
+}: InstallOptions<Addons>): Promise<ReturnType<typeof applyAddons>>;
+type ApplyAddonOptions = {
+  loadedAddons: LoadedAddon[];
+  options: OptionMap<AddonMap>;
+  workspace: Workspace;
+  setupResults: Record<string, SetupResult>;
+};
+declare function applyAddons({
+  loadedAddons,
+  workspace,
+  setupResults,
+  options
+}: ApplyAddonOptions): Promise<{
+  filesToFormat: string[];
+  pnpmBuildDependencies: string[];
+  status: Record<string, string[] | "success">;
+}>;
+//#endregion
+export { BooleanQuestion as A, defineAddon as C, WorkspaceOptions as D, Workspace as E, Question as F, SelectQuestion as I, StringQuestion as L, NumberQuestion as M, OptionDefinition as N, createWorkspace as O, OptionValues as P, officialAddons as R, Verification as S, getErrorHint as T, Scripts as _, Addon as a, TestDefinition as b, AddonReference as c, ConditionDefinition as d, ConfiguredAddon as f, PreparedAddon as g, PackageDefinition as h, add as i, MultiSelectQuestion as j, BaseQuestion as k, AddonResult as l, OptionBuilder as m, InstallOptions as n, AddonDefinition as o, LoadedAddon as p, OptionMap as r, AddonInput as s, AddonMap as t, AddonSource as u, SetupResult as v, defineAddonOptions as w, Tests as x, SvApi as y };