@deltabox/toolchain 0.0.0-stage → 1.0.7

package/dist/packages/shared/src/config-schema.js

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;import{z as e}from"zod";const t=e.enum([`monorepo-root`,`monorepo-workspace`,`project`]).describe(`The project kind (detected when omitted).`),n=e.object({type:t.optional(),name:e.string().describe(`The unscoped project name.`).optional(),scope:e.string().describe("The npm scope, eg. `@acme`.").optional(),author:e.string().describe(`Package author.`).optional(),license:e.string().describe(`SPDX license id.`).optional(),homepage:e.string().describe(`Project homepage.`).optional(),repo:e.string().describe("Repository URL, eg. `https://github.com/acme/app`.").optional(),nodeVersion:e.string().describe("Node engine range, eg. `>=22`.").optional(),packageManager:e.string().describe("Package manager name (default `yarn`).").optional(),packageManagerVersion:e.string().describe("Package manager version, eg. `4.17.1`.").optional(),description:e.string().describe(`One-line description.`).optional()}),r=e.object({name:e.string().optional(),id:e.string().optional(),if:e.string().optional(),uses:e.string().optional(),run:e.string().optional(),shell:e.string().optional(),"working-directory":e.string().optional(),with:e.record(e.string(),e.union([e.string(),e.number(),e.boolean()])).optional(),env:e.record(e.string(),e.string()).optional()}),i=e.object({job:e.string().describe(`Target job id (defaults to the primary/first job).`).optional(),before:e.array(r).describe(`Steps inserted at the start.`).optional(),after:e.array(r).describe(`Steps appended at the end.`).optional()}),a=e.object({enabled:e.boolean().describe(`Enable/disable this workflow (default true).`).optional(),pushBranches:e.array(e.string()).describe("Replace `on.push.branches`.").optional(),pullRequestBranches:e.array(e.string()).describe("Replace `on.pull_request.branches`.").optional(),triggers:e.record(e.string(),e.unknown()).describe("Extra `on.*` triggers.").optional(),extra:e.record(e.string(),e.unknown()).describe("Extra top-level keys (`permissions`, `concurrency`, `env`, ...).").optional(),steps:e.union([i,e.array(i)]).describe(`Extra steps for a job (one group, or per-job groups).`).optional(),jobs:e.record(e.string(),e.unknown()).describe(`Extra complete jobs merged in.`).optional(),tokens:e.record(e.string(),e.union([e.string(),e.number(),e.boolean()])).describe("Per-workflow token overrides (`nodeVersion`, `packageManager`, ...).").optional()}),o=e.union([e.boolean(),a]),s=e.object({ci:o.optional(),changelog:o.optional(),release:o.optional(),issues:o.optional(),sync:o.optional()}),c=e.object({enabled:e.boolean().describe(`Master switch (enabled when the section is defined).`).optional(),workflows:s.describe("Which workflows to write into `.github/workflows`.").optional(),branches:e.object({main:e.string().optional(),dev:e.string().optional()}).describe(`Branch names the workflows target.`).optional(),types:e.array(e.string()).describe(`Allowed commit types (commitlint).`).optional(),scopes:e.array(e.string()).describe(`Allowed commit scopes (commitlint).`).optional(),vscode:e.boolean().describe(`Write the Conventional-Commits VS Code settings.`).optional()}),l=e.object({enabled:e.boolean().describe(`Master switch (enabled when the section is defined).`).optional(),vscode:e.boolean().describe(`Write the Biome VS Code settings (default true).`).optional(),overrides:e.record(e.string(),e.unknown()).describe("Deep-merged over the generated `biome.json` (arrays union).").optional()}),u=e.object({enabled:e.boolean().describe(`Master switch (enabled when the section is defined).`).optional(),glob:e.string().describe("Glob for workspace `tsconfig.default.json` files.").optional(),appGlob:e.string().describe(`Glob for "override" (app) workspaces.`).optional(),refs:e.boolean().describe(`Wire project references (default false).`).optional(),composite:e.boolean().describe("Emit `composite: true` (default false).").optional(),aliases:e.boolean().describe(`Inject path aliases (default true).`).optional(),indent:e.number().describe(`JSON indentation (default 4).`).optional(),rootFile:e.string().describe("The monorepo tsconfig file name (default `tsconfig.monorepo.json`).").optional()}),d=e.object({enabled:e.boolean().describe(`Watch by default (enabled when the section is defined).`).optional(),debounce:e.number().describe(`Debounce window in ms (default 150).`).optional()}),f=e.enum([`builtin`,`local`,`npm`,`git`,`vite-plus`]).describe(`How to load the source.`),p=e.enum([`project`,`workspace`,`application`,`folder`,`tooling`,`pipeline`]).describe(`What the template produces.`),m=e.object({type:f,locate:e.string().describe(`A builtin id, local dir, npm scope, git URL or Vite+ id.`),id:e.string().describe(`Stable id (defaults to the basename/scope).`).optional(),name:e.string().describe(`Display name override.`).optional(),description:e.string().describe(`Description override.`).optional(),kind:p.optional(),ref:e.string().describe(`Git branch/tag/commit.`).optional(),subdir:e.string().describe(`Subdirectory within the source that holds the template.`).optional(),tags:e.array(e.string()).describe(`Free-form tags.`).optional(),online:e.boolean().describe(`Whether the source needs network access.`).optional()}),h=e.object({enabled:e.boolean().describe(`Master switch (enabled when the section is defined).`).optional(),sources:e.array(m).describe(`Extra sources on top of the builtin + registry sources.`).optional()}),g=e.object({enabled:e.boolean().describe(`Master switch (enabled when the section is defined).`).optional(),config:e.boolean().describe("Write the managed `vite.config.ts` (default true when the section is set).").optional(),defaultTemplate:e.string().describe("`create.defaultTemplate`, eg. `@acme` for `@acme/create`.").optional(),testInclude:e.array(e.string()).describe(`Extra Vitest include globs (default: tests under src + tests).`).optional(),lintIgnore:e.array(e.string()).describe(`Glob patterns Oxlint should ignore.`).optional(),overrides:e.record(e.string(),e.unknown()).describe("Deep-merged over the generated `vite.config.ts` object.").optional()});function _(t){return e.union([e.boolean(),t])}const v=e.object({project:n.optional(),changelog:_(c).optional(),biome:_(l).optional(),tsconfig:_(u).optional(),templates:_(h).optional(),vite:_(g).optional(),watch:_(d).optional()}),y=e.object({toolchain:v.optional()}),b={project:n,changelog:c,biome:l,tsconfig:u,templates:h,vite:g,watch:d},x={project:`Project metadata used as replacement tokens across every template.`,changelog:`Conventional-Commits CI, commitlint and the changelog pipeline.`,biome:"Biome config generation (for consumers that still want a `biome.json`).",tsconfig:`Workspace tsconfig generation (path aliases + project references).`,templates:`Template sources / scaffolding.`,vite:"Vite+ configuration (manages `vite.config.ts` + the `vite:*` commands).",watch:"Watch behaviour for `dbx watch`."};export{x as CONFIG_SECTION_DESCRIPTIONS,b as CONFIG_SECTION_SCHEMAS,l as biomeConfigSchema,c as changelogConfigSchema,s as changelogWorkflowsConfigSchema,y as dbxConfigSchema,n as projectConfigSchema,t as projectTypeSchema,p as templateKindSchema,m as templateSourceSchema,f as templateSourceTypeSchema,h as templatesConfigSchema,v as toolingConfigSchema,u as tsconfigConfigSchema,g as viteConfigSchema,d as watchConfigSchema,a as workflowConfigSchema,o as workflowSettingSchema,r as workflowStepSchema,i as workflowStepsConfigSchema};

package/dist/packages/shared/src/fs-utils.d.ts

@@ -0,0 +1,18 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+//#region packages/shared/src/fs-utils.d.ts
+/** Read + parse a JSON file, returning `undefined` when it is missing/invalid. */
+export declare function readJsonFile<T = Record<string, unknown>>(file: string): T | undefined;
+/** Read + parse a JSON file relative to `cwd`. */
+export declare function readJsonAt<T = Record<string, unknown>>(cwd: string, relative: string): T | undefined;
+/** Serialize a value to JSON text (trailing newline included). */
+export declare function toJson(value: unknown, indent?: number): string;
+/** Write JSON text to a file, creating parent directories. */
+export declare function writeJsonFile(file: string, value: unknown, indent?: number): void;
+/**
+ * Merge a patch over the existing JSON at `cwd/relative` (deep merge for
+ * objects; `recommendations`/`extensions` arrays are unioned) and return the
+ * serialized result. Used by the VS Code sync task so consumer settings survive.
+ */
+export declare function mergeJsonAt(cwd: string, relative: string, patch: Record<string, unknown>, indent?: number): string;
+//#endregion

package/dist/packages/shared/src/fs-utils.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{deepMerge as t,isPlainObject as n}from"./object-utils.js";import r from"node:fs";function i(e){try{return JSON.parse(r.readFileSync(e,`utf-8`))}catch{return}}function a(t,n){return i(e.resolve(t,n))}function o(e,t=4){return`${JSON.stringify(e,null,t)}\n`}function s(t,n,i=4){r.mkdirSync(e.dirname(t),{recursive:!0}),r.writeFileSync(t,o(n,i),`utf-8`)}function c(e,t,n,r=4){return o(l(a(e,t)??{},n),r)}function l(e,r){let i=t(e,r);for(let t of Object.keys(r)){let a=e[t],o=r[t];Array.isArray(a)&&Array.isArray(o)?i[t]=[.../* @__PURE__ */ new Set([...a,...o])]:n(a)&&n(o)&&(i[t]=l(a,o))}return i}export{c as mergeJsonAt,a as readJsonAt,i as readJsonFile,o as toJson,s as writeJsonFile};

package/dist/packages/shared/src/index.d.ts

@@ -0,0 +1,17 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { mergeJsonAt, readJsonAt, readJsonFile, toJson, writeJsonFile } from "./fs-utils.js";
+import { Sortable, deepMerge, isPlainObject, mapValues, resolveSort, sort } from "./object-utils.js";
+import { ToolingProvider, ToolingProviderAction, ToolingProviderCommand, providerActions } from "./provider.js";
+import { RunOptions, run, spawnCross } from "./run.js";
+import { asString, camelCase, camelCaseId, capitalize, constantCase, ensureLeadingSlash, ensureSlashes, ensureTrailingSlash, formatCliFlag, hasText, indent, isLocalhost, kebabCase, pascalCase, removeDoubleSlashes, removeLeadingSlash, removeTrailingSlash, sanitizeSlashes, snakeCase, str, titleCase } from "./string-utils.js";
+import { ReplacementOptions, ReplacementValue, Replacements, Replacer, applyReplacements, applyReplacementsDeep, createReplacer, defineReplacements, extractTokens, hasUnresolvedTokens, tokenPattern } from "./template.js";
+import { CONFIG_SECTION_DESCRIPTIONS, CONFIG_SECTION_SCHEMAS, ChangelogWorkflowsConfig, DbxConfigSections, ProjectType, ToolingBiomeConfig, ToolingChangelogConfig, ToolingConfigSections, ToolingProjectConfig, ToolingTemplateKind, ToolingTemplateSource, ToolingTemplateSourceType, ToolingTemplatesConfig, ToolingTsconfigConfig, ToolingViteConfig, ToolingWatchConfig, WorkflowConfig, WorkflowSetting, WorkflowStep, WorkflowStepsConfig, biomeConfigSchema, changelogConfigSchema, changelogWorkflowsConfigSchema, dbxConfigSchema, projectConfigSchema, projectTypeSchema, templateKindSchema, templateSourceSchema, templateSourceTypeSchema, templatesConfigSchema, toolingConfigSchema, tsconfigConfigSchema, viteConfigSchema, watchConfigSchema, workflowConfigSchema, workflowSettingSchema, workflowStepSchema, workflowStepsConfigSchema } from "./config-schema.js";
+import { Awaitable, GeneratedFile, JsonValue, PackageJson, ToolingArgument, ToolingCommand, ToolingCommandContext, ToolingOption } from "./types.js";
+import { CONFIG_FILE_NAMES, DbxConfig, ManagedFile, SyncContext, SyncSummary, SyncTask, ToolingConfig, ToolingHooks, ToolingSection, defineConfig, repoSlugFromUrl, resolveTokens, sectionConfig, sectionEnabled } from "./toolchain.js";
+import { YamlValue, toYaml } from "./yaml.js";
+declare namespace index_d_exports {
+  export { Awaitable, CONFIG_FILE_NAMES, CONFIG_SECTION_DESCRIPTIONS, CONFIG_SECTION_SCHEMAS, ChangelogWorkflowsConfig, DbxConfig, DbxConfigSections, GeneratedFile, JsonValue, ManagedFile, PackageJson, ProjectType, ReplacementOptions, ReplacementValue, Replacements, Replacer, RunOptions, Sortable, SyncContext, SyncSummary, SyncTask, ToolingArgument, ToolingBiomeConfig, ToolingChangelogConfig, ToolingCommand, ToolingCommandContext, ToolingConfig, ToolingConfigSections, ToolingHooks, ToolingOption, ToolingProjectConfig, ToolingProvider, ToolingProviderAction, ToolingProviderCommand, ToolingSection, ToolingTemplateKind, ToolingTemplateSource, ToolingTemplateSourceType, ToolingTemplatesConfig, ToolingTsconfigConfig, ToolingViteConfig, ToolingWatchConfig, WorkflowConfig, WorkflowSetting, WorkflowStep, WorkflowStepsConfig, YamlValue, applyReplacements, applyReplacementsDeep, asString, biomeConfigSchema, camelCase, camelCaseId, capitalize, changelogConfigSchema, changelogWorkflowsConfigSchema, constantCase, createReplacer, dbxConfigSchema, deepMerge, defineConfig, defineReplacements, ensureLeadingSlash, ensureSlashes, ensureTrailingSlash, extractTokens, formatCliFlag, hasText, hasUnresolvedTokens, indent, isLocalhost, isPlainObject, kebabCase, mapValues, mergeJsonAt, pascalCase, projectConfigSchema, projectTypeSchema, providerActions, readJsonAt, readJsonFile, removeDoubleSlashes, removeLeadingSlash, removeTrailingSlash, repoSlugFromUrl, resolveSort, resolveTokens, run, sanitizeSlashes, sectionConfig, sectionEnabled, snakeCase, sort, spawnCross, str, templateKindSchema, templateSourceSchema, templateSourceTypeSchema, templatesConfigSchema, titleCase, toJson, toYaml, tokenPattern, toolingConfigSchema, tsconfigConfigSchema, viteConfigSchema, watchConfigSchema, workflowConfigSchema, workflowSettingSchema, workflowStepSchema, workflowStepsConfigSchema, writeJsonFile };
+}
+//#endregion
+export { Awaitable, CONFIG_FILE_NAMES, CONFIG_SECTION_DESCRIPTIONS, CONFIG_SECTION_SCHEMAS, ChangelogWorkflowsConfig, DbxConfig, DbxConfigSections, GeneratedFile, JsonValue, ManagedFile, PackageJson, ProjectType, ReplacementOptions, ReplacementValue, Replacements, Replacer, RunOptions, Sortable, SyncContext, SyncSummary, SyncTask, ToolingArgument, ToolingBiomeConfig, ToolingChangelogConfig, ToolingCommand, ToolingCommandContext, ToolingConfig, ToolingConfigSections, ToolingHooks, ToolingOption, ToolingProjectConfig, ToolingProvider, ToolingProviderAction, ToolingProviderCommand, ToolingSection, ToolingTemplateKind, ToolingTemplateSource, ToolingTemplateSourceType, ToolingTemplatesConfig, ToolingTsconfigConfig, ToolingViteConfig, ToolingWatchConfig, WorkflowConfig, WorkflowSetting, WorkflowStep, WorkflowStepsConfig, type YamlValue, applyReplacements, applyReplacementsDeep, asString, biomeConfigSchema, camelCase, camelCaseId, capitalize, changelogConfigSchema, changelogWorkflowsConfigSchema, constantCase, createReplacer, dbxConfigSchema, deepMerge, defineConfig, defineReplacements, ensureLeadingSlash, ensureSlashes, ensureTrailingSlash, extractTokens, formatCliFlag, hasText, hasUnresolvedTokens, indent, index_d_exports, isLocalhost, isPlainObject, kebabCase, mapValues, mergeJsonAt, pascalCase, projectConfigSchema, projectTypeSchema, providerActions, readJsonAt, readJsonFile, removeDoubleSlashes, removeLeadingSlash, removeTrailingSlash, repoSlugFromUrl, resolveSort, resolveTokens, run, sanitizeSlashes, sectionConfig, sectionEnabled, snakeCase, sort, spawnCross, str, templateKindSchema, templateSourceSchema, templateSourceTypeSchema, templatesConfigSchema, titleCase, toJson, toYaml, tokenPattern, toolingConfigSchema, tsconfigConfigSchema, viteConfigSchema, watchConfigSchema, workflowConfigSchema, workflowSettingSchema, workflowStepSchema, workflowStepsConfigSchema, writeJsonFile };

package/dist/packages/shared/src/index.js

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;import{__exportAll as ee}from"../../../_virtual/_rolldown/runtime.js";import{deepMerge as e,isPlainObject as t,mapValues as n,resolveSort as r,sort as i}from"./object-utils.js";import{mergeJsonAt as a,readJsonAt as o,readJsonFile as s,toJson as c,writeJsonFile as l}from"./fs-utils.js";import{providerActions as u}from"./provider.js";import{run as d,spawnCross as f}from"./run.js";import{asString as p,camelCase as m,camelCaseId as h,capitalize as g,constantCase as _,ensureLeadingSlash as v,ensureSlashes as y,ensureTrailingSlash as b,formatCliFlag as x,hasText as S,indent as C,isLocalhost as w,kebabCase as T,pascalCase as E,removeDoubleSlashes as D,removeLeadingSlash as O,removeTrailingSlash as k,sanitizeSlashes as A,snakeCase as j,str as M,titleCase as N}from"./string-utils.js";import{applyReplacements as P,applyReplacementsDeep as F,createReplacer as te,defineReplacements as I,extractTokens as L,hasUnresolvedTokens as R,tokenPattern as z}from"./template.js";import{CONFIG_SECTION_DESCRIPTIONS as B,CONFIG_SECTION_SCHEMAS as V,biomeConfigSchema as H,changelogConfigSchema as U,changelogWorkflowsConfigSchema as W,dbxConfigSchema as G,projectConfigSchema as K,projectTypeSchema as q,templateKindSchema as J,templateSourceSchema as Y,templateSourceTypeSchema as X,templatesConfigSchema as Z,toolingConfigSchema as Q,tsconfigConfigSchema as $,viteConfigSchema as ne,watchConfigSchema as re,workflowConfigSchema as ie,workflowSettingSchema as ae,workflowStepSchema as oe,workflowStepsConfigSchema as se}from"./config-schema.js";import{CONFIG_FILE_NAMES as ce,defineConfig as le,repoSlugFromUrl as ue,resolveTokens as de,sectionConfig as fe,sectionEnabled as pe}from"./toolchain.js";import{toYaml as me}from"./yaml.js";var he=/* @__PURE__ */ ee({CONFIG_FILE_NAMES:()=>ce,CONFIG_SECTION_DESCRIPTIONS:()=>B,CONFIG_SECTION_SCHEMAS:()=>V,applyReplacements:()=>P,applyReplacementsDeep:()=>F,asString:()=>p,biomeConfigSchema:()=>H,camelCase:()=>m,camelCaseId:()=>h,capitalize:()=>g,changelogConfigSchema:()=>U,changelogWorkflowsConfigSchema:()=>W,constantCase:()=>_,createReplacer:()=>te,dbxConfigSchema:()=>G,deepMerge:()=>e,defineConfig:()=>le,defineReplacements:()=>I,ensureLeadingSlash:()=>v,ensureSlashes:()=>y,ensureTrailingSlash:()=>b,extractTokens:()=>L,formatCliFlag:()=>x,hasText:()=>S,hasUnresolvedTokens:()=>R,indent:()=>C,isLocalhost:()=>w,isPlainObject:()=>t,kebabCase:()=>T,mapValues:()=>n,mergeJsonAt:()=>a,pascalCase:()=>E,projectConfigSchema:()=>K,projectTypeSchema:()=>q,providerActions:()=>u,readJsonAt:()=>o,readJsonFile:()=>s,removeDoubleSlashes:()=>D,removeLeadingSlash:()=>O,removeTrailingSlash:()=>k,repoSlugFromUrl:()=>ue,resolveSort:()=>r,resolveTokens:()=>de,run:()=>d,sanitizeSlashes:()=>A,sectionConfig:()=>fe,sectionEnabled:()=>pe,snakeCase:()=>j,sort:()=>i,spawnCross:()=>f,str:()=>M,templateKindSchema:()=>J,templateSourceSchema:()=>Y,templateSourceTypeSchema:()=>X,templatesConfigSchema:()=>Z,titleCase:()=>N,toJson:()=>c,toYaml:()=>me,tokenPattern:()=>z,toolingConfigSchema:()=>Q,tsconfigConfigSchema:()=>$,viteConfigSchema:()=>ne,watchConfigSchema:()=>re,workflowConfigSchema:()=>ie,workflowSettingSchema:()=>ae,workflowStepSchema:()=>oe,workflowStepsConfigSchema:()=>se,writeJsonFile:()=>l});export{ce as CONFIG_FILE_NAMES,B as CONFIG_SECTION_DESCRIPTIONS,V as CONFIG_SECTION_SCHEMAS,P as applyReplacements,F as applyReplacementsDeep,p as asString,H as biomeConfigSchema,m as camelCase,h as camelCaseId,g as capitalize,U as changelogConfigSchema,W as changelogWorkflowsConfigSchema,_ as constantCase,te as createReplacer,G as dbxConfigSchema,e as deepMerge,le as defineConfig,I as defineReplacements,v as ensureLeadingSlash,y as ensureSlashes,b as ensureTrailingSlash,L as extractTokens,x as formatCliFlag,S as hasText,R as hasUnresolvedTokens,C as indent,w as isLocalhost,t as isPlainObject,T as kebabCase,n as mapValues,a as mergeJsonAt,E as pascalCase,K as projectConfigSchema,q as projectTypeSchema,u as providerActions,o as readJsonAt,s as readJsonFile,D as removeDoubleSlashes,O as removeLeadingSlash,k as removeTrailingSlash,ue as repoSlugFromUrl,r as resolveSort,de as resolveTokens,d as run,A as sanitizeSlashes,fe as sectionConfig,pe as sectionEnabled,j as snakeCase,i as sort,f as spawnCross,he as src_exports,M as str,J as templateKindSchema,Y as templateSourceSchema,X as templateSourceTypeSchema,Z as templatesConfigSchema,N as titleCase,c as toJson,me as toYaml,z as tokenPattern,Q as toolingConfigSchema,$ as tsconfigConfigSchema,ne as viteConfigSchema,re as watchConfigSchema,ie as workflowConfigSchema,ae as workflowSettingSchema,oe as workflowStepSchema,se as workflowStepsConfigSchema,l as writeJsonFile};

package/dist/packages/shared/src/object-utils.d.ts

@@ -0,0 +1,15 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+//#region packages/shared/src/object-utils.d.ts
+export type Sortable = Record<string, any> | [string, any][] | undefined;
+/** Sort an object's keys (or an entry tuple array) alphabetically. */
+export declare function sort<T extends Sortable>(value: T): T;
+/** Default comparator used by {@link sort}. */
+export declare function resolveSort(a: string, b: string): number;
+/** Whether a value is a non-null, non-array object. */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/** Recursively merge `sources` over `target` (arrays and scalars are replaced). */
+export declare function deepMerge<T extends Record<string, any>>(target: T, ...sources: (Partial<T> | undefined)[]): T;
+/** Map an object's values, keeping the keys. */
+export declare function mapValues<V, R>(value: Record<string, V>, fn: (value: V, key: string) => R): Record<string, R>;
+//#endregion

package/dist/packages/shared/src/object-utils.js

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;function e(e){if(!e)return e;let n=(Array.isArray(e)?e:Object.entries(e||{})).sort(([e],[n])=>t(e,n));return Array.isArray(e)?n:Object.fromEntries(n)}function t(e,t){return e.localeCompare(t)}function n(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function r(e,...t){let i={...e};for(let e of t)if(e)for(let[t,a]of Object.entries(e)){let e=i[t];n(e)&&n(a)?i[t]=r(e,a):a!==void 0&&(i[t]=a)}return i}function i(e,t){return Object.fromEntries(Object.entries(e).map(([e,n])=>[e,t(n,e)]))}export{r as deepMerge,n as isPlainObject,i as mapValues,t as resolveSort,e as sort};

package/dist/packages/shared/src/provider.d.ts

@@ -0,0 +1,66 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+//#region packages/shared/src/provider.d.ts
+/**
+ * The provider model.
+ *
+ * A *provider* is an external toolchain that `@deltabox/toolchain` exposes through
+ * its three surfaces: the `dbx` CLI, the programmatic API and the VS
+ * Code extension. A provider wraps a binary (eg. Vite+'s `vp`) and contributes
+ * namespaced CLI commands (`vite:dev`, `vite:build`, ...) plus the metadata the
+ * extension needs to build menus and run everything through the CLI.
+ *
+ * Providers stay framework-agnostic: they never import a CLI/editor framework,
+ * they just describe commands + actions. The root CLI and the extension consume
+ * this description (the extension over `dbx providers --json`).
+ */
+/** A CLI command a provider contributes (namespaced, eg. `vite:dev`). */
+export interface ToolingProviderCommand {
+  /** The namespaced `dbx` command name, eg. `vite:dev`. */
+  name: string;
+  /** The wrapped subcommand on the provider binary, eg. `dev`. */
+  subcommand: string;
+  /** Human-readable description. */
+  description: string;
+  /** UI group (eg. `develop`, `build`, `deps`). */
+  group?: string;
+  /** Alternate names the binary accepts, eg. `i` for `install`. */
+  aliases?: string[];
+}
+/** A curated action the VS Code extension can surface for a provider. */
+export interface ToolingProviderAction {
+  /** Stable id, unique within the provider. */
+  id: string;
+  /** Menu label. */
+  label: string;
+  /** Longer description / tooltip. */
+  description?: string;
+  /** The `dbx` command to run (no args). */
+  command: string;
+  /** UI group. */
+  group?: string;
+}
+/** A provider descriptor consumed by the CLI + the VS Code extension. */
+export interface ToolingProvider {
+  /** Stable id, eg. `vite-plus`. */
+  id: string;
+  /** Display name, eg. `Vite+`. */
+  name: string;
+  /** One-line description. */
+  description?: string;
+  /** Project homepage. */
+  homepage?: string;
+  /** The external binary the provider wraps, eg. `vp`. */
+  binary?: string;
+  /** The commands the provider contributes to the CLI. */
+  commands: ToolingProviderCommand[];
+  /** Curated actions for the extension (defaults to one per command). */
+  actions?: ToolingProviderAction[];
+}
+/**
+ * Derive the default actions (one per command) for a provider that does not
+ * declare its own. This keeps a provider descriptor minimal while still giving
+ * the extension something to render.
+ */
+export declare function providerActions(provider: ToolingProvider): ToolingProviderAction[];
+//#endregion

package/dist/packages/shared/src/provider.js

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;function e(e){return e.actions?.length?e.actions:e.commands.map(e=>({id:e.name.replace(/[:]/g,`-`),label:e.description,command:e.name,...e.group?{group:e.group}:{}}))}export{e as providerActions};

package/dist/packages/shared/src/run.d.ts

@@ -0,0 +1,26 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ChildProcess, SpawnOptions } from "node:child_process";
+//#region packages/shared/src/run.d.ts
+export interface RunOptions extends SpawnOptions {
+  /** Exit the main process with the child's exit code (default true). */
+  exitWithMainProc?: boolean;
+  /** Append a trailing `--` to the args (default true). */
+  argsEndingDashes?: boolean;
+  /** Log the command before spawning (default true). */
+  verbose?: boolean;
+}
+/**
+ * Spawn a command without a shell in a cross-platform safe way, returning the
+ * child process. On Windows the command and every argument are escaped for
+ * `cmd.exe` (and a `.cmd`/`.bat` shim is re-escaped) so a caller-supplied argv
+ * value can never inject a command. `options.stdio` defaults to `inherit`.
+ */
+export declare function spawnCross(cmd: string, args: string[], options?: SpawnOptions): ChildProcess;
+/**
+ * Spawn a command without a shell in a cross-platform safe way. On Windows the
+ * command and every argument are escaped for `cmd.exe` so a caller-supplied
+ * argv value can never inject a command.
+ */
+export declare function run(cmd: string, args: string[], options?: RunOptions): ChildProcess;
+//#endregion

package/dist/packages/shared/src/run.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import t from"node:fs";import{spawn as n}from"node:child_process";const r=process.platform===`win32`,i=/([()\][%!^"`<>&|;, *?])/g;function a(e){return e.replace(i,`^$1`)}function o(e,t){let n=String(e);return n=n.replace(/(?=(\\+?)?)\1"/g,`$1$1\\"`),n=n.replace(/(?=(\\+?)?)\1$/,`$1$1`),n=`"${n}"`,n=n.replace(i,`^$1`),t&&(n=n.replace(i,`^$1`)),n}function s(n){if(e.extname(n))return t.existsSync(n)?n:void 0;let r=(process.env.PATHEXT??`.COM;.EXE;.BAT;.CMD`).split(`;`),i=(process.env.PATH??``).split(e.delimiter);for(let a of r)for(let r of i){let i=e.join(r,`${n}${a.toLowerCase()}`);if(t.existsSync(i))return i}}function c(e){let t=s(e)??e;return/\.(cmd|bat)$/i.test(t)}function l(e,t,i={}){if(r){let r=c(e),s=[a(e),...t.map(e=>o(e,r))].join(` `);return n(process.env.ComSpec??`cmd.exe`,[`/d`,`/s`,`/c`,`"${s}"`],{stdio:`inherit`,...i,shell:!1,windowsVerbatimArguments:!0})}return n(e,t,{stdio:`inherit`,...i,shell:!1})}function u(e,t,n){let{exitWithMainProc:r=!0,argsEndingDashes:i=!0,verbose:a=!0,...o}=n??{},s=[...t,...i?[`--`]:[]];a&&console.log(`$ ${e} ${s.join(` `)}`);let c=l(e,s,o);return r&&c.on(`exit`,process.exit),c}export{u as run,l as spawnCross};

package/dist/packages/shared/src/string-utils.d.ts

@@ -0,0 +1,52 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+//#region packages/shared/src/string-utils.d.ts
+/** Coerce a value to a trimmed string. */
+export declare function str(v: unknown): string;
+/** Coerce a value to a string without trimming. */
+export declare function asString(v: unknown): string;
+/** Whether a value looks like a non-empty string after trimming. */
+export declare function hasText(v: unknown): v is string;
+/** Uppercase the first letter of a string (no-op on empty input). */
+export declare function capitalize(text: string): string;
+/** `foo bar` -> `fooBar`. */
+export declare function camelCase(text: string): string;
+/** `foo bar` -> `FooBar`. */
+export declare function pascalCase(text: string): string;
+/** `foo bar` -> `foo-bar`. */
+export declare function kebabCase(text: string): string;
+/** `foo bar` -> `foo_bar`. */
+export declare function snakeCase(text: string): string;
+/** `foo bar` -> `FOO_BAR`. */
+export declare function constantCase(text: string): string;
+/** `foo bar` -> `Foo Bar`. */
+export declare function titleCase(text: string): string;
+/**
+ * Convert an operation id into a camelCase identifier:
+ * `hosts.list` -> `hostsList`, `auth.login` -> `authLogin`.
+ */
+export declare function camelCaseId(operationId: string): string;
+/**
+ * Turn an env-var-ish identifier into a CLI flag, stripping a prefix:
+ * `MYAPP_CLI_BASE_URL` -> `base-url` (with prefix `MYAPP_`).
+ */
+export declare function formatCliFlag(env: string, prefix?: string): string;
+/** Indent every non-empty line of a string. */
+export declare function indent(text: string, spaces?: number): string;
+/** Whether a URI points at a local host (localhost, 127.0.0.1, 0.0.0.0, ::). */
+export declare function isLocalhost(uri: string): boolean;
+/** Ensure a string starts with `slash`. */
+export declare function ensureLeadingSlash(value: string, slash?: string): string;
+/** Ensure a string ends with `slash`. */
+export declare function ensureTrailingSlash(value: string, slash?: string): string;
+/** Remove leading slashes from a string. */
+export declare function removeLeadingSlash(value: string, slash?: string): string;
+/** Remove trailing slashes from a string. */
+export declare function removeTrailingSlash(value: string, slash?: string): string;
+/** Collapse repeated slashes in a string. */
+export declare function removeDoubleSlashes(value: string, slash?: string): string;
+/** Sanitize slashes with the given operations (default: all). */
+export declare function sanitizeSlashes(value: string, operations?: ('leading' | 'trailing' | 'double')[], slash?: string): string;
+/** Ensure slashes at the requested positions. */
+export declare function ensureSlashes(value: string, operations: ('leading' | 'trailing')[], slash?: string): string;
+//#endregion

package/dist/packages/shared/src/string-utils.js

@@ -0,0 +1,3 @@
+import"node:path";import"node:url";import.meta.url;function e(e){return typeof e==`string`?e.trim():``}function t(e){return typeof e==`string`?e:``}function n(e){return typeof e==`string`&&e.trim().length>0}function r(e){return e.length>0?e.charAt(0).toUpperCase()+e.slice(1):e}function i(e){return e.replace(/([a-z0-9])([A-Z])/g,`$1 $2`).split(/[^a-zA-Z0-9]+/).filter(Boolean)}function a(e){return i(e).map((e,t)=>t===0?e.toLowerCase():r(e.toLowerCase())).join(``)}function o(e){return i(e).map(e=>r(e.toLowerCase())).join(``)}function s(e){return i(e).map(e=>e.toLowerCase()).join(`-`)}function c(e){return i(e).map(e=>e.toLowerCase()).join(`_`)}function l(e){return i(e).map(e=>e.toUpperCase()).join(`_`)}function u(e){return i(e).map(e=>r(e.toLowerCase())).join(` `)}function d(e){return a(e)}function f(e,t=``){return s(t&&e.startsWith(t)?e.slice(t.length):e)}function p(e,t=2){let n=` `.repeat(t);return e.split(`
+`).map(e=>e.trim()?n+e:e).join(`
+`)}function m(e){return/localhost|127\.0\.0\.1|0\.0\.0\.0|::/.test(e)}function h(e,t=`/`){return e.startsWith(t)?e:`${t}${e}`}function g(e,t=`/`){return e.endsWith(t)?e:`${e}${t}`}function _(e,t=`/`){return e.replace(RegExp(`^${S(t)}+`),``)}function v(e,t=`/`){return e.replace(RegExp(`${S(t)}+$`),``)}function y(e,t=`/`){return e.replace(RegExp(`${S(t)}+`,`g`),t)}function b(e,t=[`leading`,`trailing`,`double`],n=`/`){let r=e;for(let e of t)e===`leading`&&(r=_(r,n)),e===`trailing`&&(r=v(r,n)),e===`double`&&(r=y(r,n));return r}function x(e,t,n=`/`){if(!t.length)throw Error(`ensureSlashes: operations array cannot be empty.`);let r=e;for(let e of t)if(e===`leading`)r=h(r,n);else if(e===`trailing`)r=g(r,n);else throw Error(`ensureSlashes: invalid operation: ${e}`);return r}function S(e){return e===`/`?`\\/`:e}export{t as asString,a as camelCase,d as camelCaseId,r as capitalize,l as constantCase,h as ensureLeadingSlash,x as ensureSlashes,g as ensureTrailingSlash,f as formatCliFlag,n as hasText,p as indent,m as isLocalhost,s as kebabCase,o as pascalCase,y as removeDoubleSlashes,_ as removeLeadingSlash,v as removeTrailingSlash,b as sanitizeSlashes,c as snakeCase,e as str,u as titleCase};

package/dist/packages/shared/src/template.d.ts

@@ -0,0 +1,53 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+//#region packages/shared/src/template.d.ts
+/**
+ * Generic replacement/template engine.
+ *
+ * All `@deltabox/toolchain` templates and generated files are authored with
+ * `{{ token }}` placeholders (e.g. `{{name}}`, `{{scope}}`, `{{envPrefix}}`)
+ * so a consumer can retarget the tooling at any project by supplying its own
+ * replacement values. Tokens support an inline default: `{{name:my-app}}`.
+ */
+/** A replacement value. Falsy-but-defined values are stringified. */
+export type ReplacementValue = string | number | boolean | null | undefined;
+/** A map of token name to replacement value. */
+export interface Replacements {
+  [key: string]: ReplacementValue;
+}
+export interface ReplacementOptions {
+  /** Opening token delimiter (default `{{`). */
+  open?: string;
+  /** Closing token delimiter (default `}}`). */
+  close?: string;
+  /** Keep unresolved tokens as-is instead of erasing them (default true). */
+  keepUnresolved?: boolean;
+  /** Throw when a token cannot be resolved (default false). */
+  strict?: boolean;
+  /** Transform every resolved value before it is written. */
+  transform?: (value: string, key: string) => string;
+}
+/** A compiled replacer: feed it a string, get the rendered string back. */
+export type Replacer = (input: string) => string;
+/** Build the token-matching regular expression for the given delimiters. */
+export declare function tokenPattern(open?: string, close?: string): RegExp;
+/**
+ * Replace every `{{ token }}` (or custom delimiter) occurrence in `input`
+ * using `replacements`. Missing tokens fall back to their inline default, then
+ * to the `keepUnresolved`/`strict` policy.
+ */
+export declare function applyReplacements(input: string, replacements?: Replacements, options?: ReplacementOptions): string;
+/** Create a reusable {@link Replacer} bound to a replacement map. */
+export declare function createReplacer(replacements?: Replacements, options?: ReplacementOptions): Replacer;
+/**
+ * Recursively apply replacements to an arbitrary value. Strings are rendered;
+ * arrays and plain objects are walked; everything else is returned as-is.
+ */
+export declare function applyReplacementsDeep<T>(value: T, replacements?: Replacements, options?: ReplacementOptions): T;
+/** Every distinct token name referenced by `input`. */
+export declare function extractTokens(input: string, options?: ReplacementOptions): string[];
+/** Whether `input` still contains any token (resolved or not). */
+export declare function hasUnresolvedTokens(input: string): boolean;
+/** Identity helper that keeps replacement maps type-checked at the call site. */
+export declare function defineReplacements<T extends Replacements>(replacements: T): T;
+//#endregion

package/dist/packages/shared/src/template.js

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;function e(e){return e.replace(/[.*+?^${}()|[\]\\]/g,`\\$&`)}function t(t=`{{`,n=`}}`){return RegExp(`${e(t)}\\s*([\\w.@/-]+)\\s*(?::\\s*([^]*?))?\\s*${e(n)}`,`g`)}function n(e){return e==null?``:String(e)}function r(e,r={},i={}){let{open:a=`{{`,close:o=`}}`,keepUnresolved:s=!0,strict:c=!1,transform:l}=i,u=t(a,o);return e.replace(u,(e,t,i)=>{if(Object.hasOwn(r,t)){let e=n(r[t]);return l?l(e,t):e}if(i!==void 0)return i.trim();if(c)throw Error(`Missing replacement for token "{{${t}}}"`);return s?e:``})}function i(e={},t={}){return n=>r(n,e,t)}function a(e,t={},n={}){if(typeof e==`string`)return r(e,t,n);if(Array.isArray(e))return e.map(e=>a(e,t,n));if(e&&typeof e==`object`){let r={};for(let[i,o]of Object.entries(e))r[i]=a(o,t,n);return r}return e}function o(e,n={}){let r=t(n.open,n.close),i=/* @__PURE__ */ new Set;for(let t of e.matchAll(r))t[1]&&i.add(t[1]);return[...i]}function s(e){let n=t();return n.lastIndex=0,n.test(e)}function c(e){return e}export{r as applyReplacements,a as applyReplacementsDeep,i as createReplacer,c as defineReplacements,o as extractTokens,s as hasUnresolvedTokens,t as tokenPattern};

package/dist/packages/shared/src/toolchain.d.ts

@@ -0,0 +1,159 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { Replacements } from "./template.js";
+import { CONFIG_SECTION_DESCRIPTIONS, CONFIG_SECTION_SCHEMAS, ChangelogWorkflowsConfig, DbxConfigSections, ProjectType, ToolingBiomeConfig, ToolingChangelogConfig, ToolingConfigSections, ToolingProjectConfig, ToolingTemplateKind, ToolingTemplateSource, ToolingTemplateSourceType, ToolingTemplatesConfig, ToolingTsconfigConfig, ToolingViteConfig, ToolingWatchConfig, WorkflowConfig, WorkflowSetting, WorkflowStep, WorkflowStepsConfig, biomeConfigSchema, changelogConfigSchema, changelogWorkflowsConfigSchema, dbxConfigSchema, projectConfigSchema, projectTypeSchema, templateKindSchema, templateSourceSchema, templateSourceTypeSchema, templatesConfigSchema, toolingConfigSchema, tsconfigConfigSchema, viteConfigSchema, watchConfigSchema, workflowConfigSchema, workflowSettingSchema, workflowStepSchema, workflowStepsConfigSchema } from "./config-schema.js";
+import { Awaitable } from "./types.js";
+//#region packages/shared/src/toolchain.d.ts
+/** A summary of a sync run, handed to {@link ToolingHooks.afterSync}. */
+export interface SyncSummary {
+  written: string[];
+  changed: string[];
+  removed: string[];
+  upToDate: boolean;
+}
+/**
+ * Lifecycle hooks, declared as functions in `dbx.config.ts` (so they only work
+ * from a `.ts`/`.js` config, not JSON). Return values are awaited.
+ */
+export interface ToolingHooks {
+  /** Runs after the config is loaded + tokens resolved. */
+  afterLoad?: (info: {
+    cwd: string;
+    config: ToolingConfig;
+    tokens: Replacements;
+    path?: string;
+  }) => Awaitable<void>;
+  /** Runs once before the sync tasks. */
+  beforeSync?: (ctx: SyncContext) => Awaitable<void>;
+  /** Runs before each task. */
+  beforeTask?: (info: {
+    task: SyncTask;
+    ctx: SyncContext;
+  }) => Awaitable<void>;
+  /** Runs after each task (with the files it produced, if any). */
+  afterTask?: (info: {
+    task: SyncTask;
+    ctx: SyncContext;
+    files?: ManagedFile[];
+  }) => Awaitable<void>;
+  /** Runs once after the sync tasks with the result summary. */
+  afterSync?: (info: {
+    cwd: string;
+    config: ToolingConfig;
+    result: SyncSummary;
+  }) => Awaitable<void>;
+  /** Runs on every watch-triggered change. */
+  onChange?: (info: {
+    path?: string;
+  }) => Awaitable<void>;
+}
+/**
+ * The complete tooling configuration a consumer declares (under
+ * `dbx.toolchain`).
+ *
+ * Every section is **opt-in by presence** (see {@link sectionEnabled}): define a
+ * section to enable it; omit it to leave that area untouched. Within a defined
+ * section, `enabled: false` disables it explicitly.
+ */
+export type ToolingConfig = ToolingConfigSections & {
+  hooks?: ToolingHooks;
+};
+/**
+ * The root shape of a `dbx.config.*` file. The `@deltabox/toolchain` settings
+ * live under the `toolchain` key, so `dbx.config` can host other dbx concerns
+ * alongside it.
+ */
+export interface DbxConfig {
+  toolchain?: ToolingConfig;
+}
+/**
+ * Identity helper that gives a config file full type-checking + autocomplete.
+ * Mirrors Vite's `defineConfig`: `export default defineConfig({ toolchain: { ... } })`.
+ */
+export declare function defineConfig(config: DbxConfig): DbxConfig;
+/**
+ * A config section that is enabled with `true`, disabled with `false`, or
+ * configured with an options object.
+ */
+export type ToolingSection<T> = boolean | T;
+/**
+ * Whether an optional top-level config section is enabled.
+ *
+ * Sections are **opt-in by presence**: a section only runs when it is defined
+ * in `dbx.config.*` (and not explicitly disabled). A consumer can
+ * enable a tooling area with the boolean shorthand (`biome: true`) when it needs
+ * no options, or configure it with an object (`biome: { overrides: { ... } }`).
+ * Either way the tooling never touches an area the consumer did not ask for.
+ */
+export declare function sectionEnabled(section: ToolingSection<{
+  enabled?: boolean;
+}> | undefined): boolean;
+/** The options object for a section (`undefined` when it is a boolean/absent). */
+export declare function sectionConfig<T extends {
+  enabled?: boolean;
+}>(section: ToolingSection<T> | undefined): T | undefined;
+/** The file names a config loader looks for, in priority order. */
+export declare const CONFIG_FILE_NAMES: readonly ['dbx.config.ts', 'dbx.config.mts', 'dbx.config.js', 'dbx.config.mjs', 'dbx.config.cjs', 'dbx.config.json'];
+/** Derive the `owner/name` slug from a repository URL. */
+export declare function repoSlugFromUrl(repo: string | undefined): string | undefined;
+/**
+ * Flatten a {@link ToolingConfig} into the `{{ token }}` replacements every
+ * template understands. Defaults are chosen so a bare config still renders.
+ */
+export declare function resolveTokens(config?: ToolingConfig): Replacements;
+/** A file written by a sync task (its parent directory is created as needed). */
+export interface ManagedFile {
+  /** Path relative to the project root. */
+  path: string;
+  /** The file content. */
+  content: string;
+  /**
+   * A comment inserted at the top marking the file as managed (skipped for
+   * JSON files, which are tracked via the manifest instead).
+   */
+  header?: string;
+}
+/** The context handed to every {@link SyncTask}. */
+export interface SyncContext {
+  /** The project root. */
+  cwd: string;
+  /** The detected/configured project kind. */
+  projectType: ProjectType;
+  /** The loaded config. */
+  config: ToolingConfig;
+  /** The resolved replacement tokens. */
+  tokens: Replacements;
+  /** Log a line (respects `--quiet`). */
+  log: (message: string) => void;
+}
+/** A unit of sync work exposed by a package. */
+export interface SyncTask {
+  /** Stable id, used in logs + the manifest. */
+  name: string;
+  /**
+   * Repo-relative globs to watch; a change re-runs this task. The config file
+   * itself is always watched, and re-runs every task.
+   */
+  watch?: string[];
+  /**
+   * File names/suffixes the task does **not** own but that may appear in an
+   * older manifest. They are never deleted (even though they are no longer
+   * generated) and are dropped from the manifest, so a consumer can edit them
+   * freely — eg. `tsconfig.build.json`.
+   */
+  keep?: string[];
+  /** Whether the task runs for the given config (default: always). */
+  enabled?: (config: ToolingConfig) => boolean;
+  /**
+   * The project kinds the task applies to (default: all). A task is skipped
+   * when the resolved project type is not in this list.
+   */
+  projectTypes?: ProjectType[];
+  /**
+   * Run the task. Returns the managed files to write, and/or performs side
+   * effects directly (eg. the tsconfig task regenerates files itself).
+   */
+  run: (ctx: SyncContext) => Awaitable<ManagedFile[] | void>;
+}
+//#endregion
+export { CONFIG_SECTION_DESCRIPTIONS, CONFIG_SECTION_SCHEMAS, ChangelogWorkflowsConfig, DbxConfigSections, ProjectType, ToolingBiomeConfig, ToolingChangelogConfig, ToolingConfigSections, ToolingProjectConfig, ToolingTemplateKind, ToolingTemplateSource, ToolingTemplateSourceType, ToolingTemplatesConfig, ToolingTsconfigConfig, ToolingViteConfig, ToolingWatchConfig, WorkflowConfig, WorkflowSetting, WorkflowStep, WorkflowStepsConfig, biomeConfigSchema, changelogConfigSchema, changelogWorkflowsConfigSchema, dbxConfigSchema, projectConfigSchema, projectTypeSchema, templateKindSchema, templateSourceSchema, templateSourceTypeSchema, templatesConfigSchema, toolingConfigSchema, tsconfigConfigSchema, viteConfigSchema, watchConfigSchema, workflowConfigSchema, workflowSettingSchema, workflowStepSchema, workflowStepsConfigSchema };

package/dist/packages/shared/src/toolchain.js

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;import{CONFIG_SECTION_DESCRIPTIONS as e,CONFIG_SECTION_SCHEMAS as t,biomeConfigSchema as n,changelogConfigSchema as r,changelogWorkflowsConfigSchema as i,dbxConfigSchema as a,projectConfigSchema as o,projectTypeSchema as s,templateKindSchema as c,templateSourceSchema as l,templateSourceTypeSchema as u,templatesConfigSchema as d,toolingConfigSchema as f,tsconfigConfigSchema as p,viteConfigSchema as m,watchConfigSchema as h,workflowConfigSchema as g,workflowSettingSchema as _,workflowStepSchema as v,workflowStepsConfigSchema as y}from"./config-schema.js";function b(e){return e}function x(e){return e===void 0?!1:typeof e==`boolean`?e:e.enabled!==!1}function S(e){return e!==void 0&&typeof e==`object`?e:void 0}const C=[`dbx.config.ts`,`dbx.config.mts`,`dbx.config.js`,`dbx.config.mjs`,`dbx.config.cjs`,`dbx.config.json`];function w(e){if(!e)return;let t=e.match(/github\.com[/:]([^/]+)\/([^/.]+?)(?:\.git)?$/);return t?.[1]&&t[2]?`${t[1]}/${t[2]}`:void 0}function T(e={}){let t=e.project??{},n=S(e.changelog)??{};return{name:t.name??`app`,scope:t.scope??``,author:t.author??``,license:t.license??`MIT`,homepage:t.homepage??``,repo:t.repo??``,repoSlug:w(t.repo)??``,description:t.description??``,nodeVersion:t.nodeVersion??`22`,packageManager:t.packageManager??`yarn`,yarnVersion:t.packageManagerVersion??`4.17.1`,packageManagerVersion:t.packageManagerVersion??`4.17.1`,mainBranch:n.branches?.main??`main`,devBranch:n.branches?.dev??`dev`}}export{C as CONFIG_FILE_NAMES,e as CONFIG_SECTION_DESCRIPTIONS,t as CONFIG_SECTION_SCHEMAS,n as biomeConfigSchema,r as changelogConfigSchema,i as changelogWorkflowsConfigSchema,a as dbxConfigSchema,b as defineConfig,o as projectConfigSchema,s as projectTypeSchema,w as repoSlugFromUrl,T as resolveTokens,S as sectionConfig,x as sectionEnabled,c as templateKindSchema,l as templateSourceSchema,u as templateSourceTypeSchema,d as templatesConfigSchema,f as toolingConfigSchema,p as tsconfigConfigSchema,m as viteConfigSchema,h as watchConfigSchema,g as workflowConfigSchema,_ as workflowSettingSchema,v as workflowStepSchema,y as workflowStepsConfigSchema};

package/dist/packages/shared/src/types.d.ts

@@ -0,0 +1,100 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { Replacements } from "./template.js";
+import { ProjectType } from "./config-schema.js";
+import { ToolingConfig } from "./toolchain.js";
+//#region packages/shared/src/types.d.ts
+/** A value that may or may not be awaited. */
+export type Awaitable<T> = T | Promise<T>;
+/** A file that was written by a generator: an absolute path plus its content. */
+export interface GeneratedFile {
+  path: string;
+  content: string;
+}
+/** Any JSON-serializable value. */
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+/** A CLI option a tooling command exposes (framework-agnostic). */
+export interface ToolingOption {
+  /** Commander-style flags, eg. `-o, --out <path>`. */
+  flags: string;
+  /** Human-readable description. */
+  description: string;
+  /** Optional default value (stringified). */
+  default?: string;
+}
+/**
+ * The context handed to every command after the consumer's
+ * `dbx.config.*` has been loaded, so a command can derive its defaults
+ * from the config; explicit CLI flags override those defaults.
+ */
+export interface ToolingCommandContext {
+  /** The project root the config was loaded from. */
+  cwd: string;
+  /** The detected/configured project kind. */
+  projectType: ProjectType;
+  /** The loaded tooling config (empty object when none was found). */
+  config: ToolingConfig;
+  /** The resolved replacement tokens. */
+  tokens: Replacements;
+  /** The config file that was loaded, if any. */
+  configPath?: string;
+}
+/** A positional argument a command accepts. */
+export interface ToolingArgument {
+  /** The argument name (also its key in the run `args` object). */
+  name: string;
+  /** Human-readable description. */
+  description: string;
+  /** Accept one value (default) or many (variadic, collected into an array). */
+  variadic?: boolean;
+  /** Whether the argument is required (default true). */
+  required?: boolean;
+}
+/**
+ * A framework-agnostic command description. Packages export these (eg.
+ * `configCommands()`) and the root `dbx` CLI registers them with
+ * commander, so packages never depend on a CLI framework. `args` contains only
+ * the flags explicitly passed on the command line (so config defaults apply
+ * otherwise); `context` carries the loaded config.
+ */
+export interface ToolingCommand<Args extends Record<string, unknown> = Record<string, unknown>> {
+  /** The command name, eg. `config` or `generate`. */
+  name: string;
+  /** Human-readable description. */
+  description: string;
+  /** Positional arguments the command accepts. */
+  args?: ToolingArgument[];
+  /** Options the command accepts. */
+  options?: ToolingOption[];
+  /**
+   * Forward every operand (including unknown flags) to the command instead of
+   * parsing them. Used by provider passthrough commands (eg. `vite:dev`), which
+   * hand their raw argv to the wrapped binary. The raw operands arrive under
+   * the `args` key of the run argument (typed `string[]`).
+   */
+  passthrough?: boolean;
+  /** Run the command with the CLI-provided options + the loaded config. */
+  run: (args: Args, context: ToolingCommandContext) => Awaitable<void>;
+}
+/** A package.json-shaped object (loose; only the fields the tooling touches). */
+export interface PackageJson {
+  name?: string;
+  version?: string;
+  private?: boolean;
+  type?: string;
+  description?: string;
+  scripts?: Record<string, string>;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  optionalDependencies?: Record<string, string>;
+  workspaces?: string[] | {
+    packages?: string[];
+  };
+  exports?: Record<string, unknown> | string;
+  files?: string[];
+  [key: string]: unknown;
+}
+//#endregion

package/dist/packages/shared/src/yaml.d.ts

@@ -0,0 +1,17 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+//#region packages/shared/src/yaml.d.ts
+/**
+ * A tiny, dependency-free YAML emitter for the subset GitHub Actions needs:
+ * nested maps, arrays (inline or block), booleans/numbers/null, and multi-line
+ * block scalars (`run: |`). It is intentionally conservative — string scalars
+ * that could be misread (booleans, numbers, `#`, `: `, `${{ }}`, ...) are
+ * double-quoted.
+ */
+type YamlValue = string | number | boolean | null | YamlValue[] | {
+  [key: string]: YamlValue;
+};
+/** Serialize a value (expected to be a map) to a YAML document. */
+export declare function toYaml(value: Record<string, YamlValue>): string;
+//#endregion
+export type { YamlValue };

package/dist/packages/shared/src/yaml.js

@@ -0,0 +1,5 @@
+import"node:path";import"node:url";import.meta.url;const e=/^(?:true|false|yes|no|on|off|null|~)$/i,t=/^[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?$/;function n(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function r(n){return!!(n===``||e.test(n)||t.test(n)||/^[\s\-?:,[\]{}#&*!|>%@`"']/.test(n)||/\s$/.test(n)||n.includes(`: `)||n.includes(` #`)||n.includes(`	`)||n.includes("${{")||/["\\]/.test(n))}function i(e){return e===null?`null`:typeof e==`boolean`?e?`true`:`false`:typeof e==`number`?String(e):r(e)?`"${e.replace(/\\/g,`\\\\`).replace(/"/g,`\\"`)}"`:e}function a(t){return r(t)&&!e.test(t)?`"${t}"`:t}function o(e){return e.reduce((e,t)=>e+String(s(t)).length+2,0)}function s(e){return e}function c(e){return e===null||typeof e==`string`||typeof e==`number`||typeof e==`boolean`}function l(e,t){let r=` `.repeat(t),a=[];for(let o of e)if(c(o))a.push(`${r}- ${i(o)}`);else if(Array.isArray(o))a.push(`${r}-`),a.push(...l(o,t+2));else if(n(o)){let e=d(o,t+2),n=e[0];if(n===void 0)a.push(`${r}- {}`);else{a.push(`${r}- ${n.slice(t+2)}`);for(let t=1;t<e.length;t+=1)a.push(e[t])}}return a}function u(e,t,n,r){let i=e.endsWith(`
+`)?e.slice(0,-1):e,a=[`${n}${r}: |`];for(let e of i.split(`
+`))a.push(e===``?``:`${` `.repeat(t+2)}${e}`);return a}function d(e,t){let r=` `.repeat(t),f=[];for(let[p,m]of Object.entries(e)){if(m===void 0)continue;let e=a(p);typeof m==`string`&&m.includes(`
+`)?f.push(...u(m,t,r,e)):c(m)?f.push(`${r}${e}: ${i(m)}`):Array.isArray(m)?m.length===0?f.push(`${r}${e}: []`):m.every(c)&&o(m)<=60?f.push(`${r}${e}: [${m.map(e=>i(s(e))).join(`, `)}]`):(f.push(`${r}${e}:`),f.push(...l(m,t+2))):n(m)&&(Object.keys(m).length===0?f.push(`${r}${e}: {}`):(f.push(`${r}${e}:`),f.push(...d(m,t+2))))}return f}function f(e){return`${d(e,0).join(`
+`)}\n`}export{f as toYaml};

package/dist/packages/template/src/builtin.d.ts

@@ -0,0 +1,10 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { Template } from "./types.js";
+//#region packages/template/src/builtin.d.ts
+/**
+ * The built-in, offline templates. They map onto the local generators in
+ * `@deltabox/toolchain-project`, so they need no files on disk or network.
+ */
+export declare const BUILTIN_TEMPLATES: Template[];
+//#endregion