@deltabox/toolchain 0.0.0-stage → 1.1.21

package/dist/packages/config/src/generators/markdown.d.ts

@@ -0,0 +1,77 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ConfigScopes } from "../types.js";
+import { CollectEnvVarsOptions } from "../collect.js";
+import { ZodType } from "zod";
+import { Schema } from "untyped";
+//#region packages/config/src/generators/markdown.d.ts
+export interface RenderMarkdownOptions {
+  /** Output directory. When omitted, nothing is written. */
+  outDir?: string;
+  /** Page outline (defaults to `[2, 3, 4]`). */
+  outline?: number[];
+  /** The base group hoisted out of the nested groups (default `base`). */
+  baseGroup?: string;
+  /** The scope whose env vars render as CLI flags (default `cli`). */
+  cliScope?: string;
+  /** Env-var prefix (default `APP_`). */
+  envPrefix?: string;
+  /** Label overrides for the index page. */
+  labels?: {
+    required?: string;
+    core?: string;
+    title?: string;
+  };
+  /** A raw intro paragraph for the index page (replaces the default one). */
+  intro?: string;
+  /** A note shown above the required table (default: the standard sentence). */
+  requiredNote?: string;
+  /** A note shown above the core table (default: the standard sentence). */
+  coreNote?: string;
+  /** A "References" list appended to the index page. */
+  references?: {
+    label: string;
+    href: string;
+  }[];
+  /** Shorthand flags keyed by env var name (for the CLI scope). */
+  shortFlags?: Record<string, string>;
+  /** Custom env-name -> dotted-path derivation. */
+  envPathOf?: CollectEnvVarsOptions['envPathOf'];
+}
+export interface GenerateMarkdownOptions extends RenderMarkdownOptions {
+  /** Index file name (defaults to `index.md`). */
+  indexFilename?: string;
+}
+/** Render the markdown reference for a single scope (base + grouped configs). */
+export declare function renderScopeMarkdown(scope: string, schema: Schema, options?: RenderMarkdownOptions): string;
+/** Render the index file: explains the env convention + lists required/core. */
+export declare function renderConfigIndex(scopes: ConfigScopes, options?: RenderMarkdownOptions): string;
+/** Generate the markdown reference (per-scope files + index) into `outDir`. */
+export declare function generateConfigMarkdown(scopes: ConfigScopes, options: GenerateMarkdownOptions & {
+  outDir: string;
+}): string[];
+/** A section of a config-file reference (its key + options schema). */
+export interface ConfigFileSection {
+  /** The config key, eg. `project`. */
+  key: string;
+  /** A short description shown under the heading. */
+  description?: string;
+  /** The section's options-object schema. */
+  schema: ZodType;
+}
+export interface RenderConfigFileOptions {
+  /** Document title (default `Configuration`). */
+  title?: string;
+  /** Intro paragraph under the title. */
+  intro?: string;
+  /** Page outline (default `[2, 3, 4]`). */
+  outline?: number[];
+}
+/**
+ * Render a single markdown reference for a config **file** (no environment-var
+ * language): one `## \`key\`` section per schema, with its fields, types,
+ * defaults and descriptions. This is what a `dbx.config.ts`-style
+ * reference is generated from.
+ */
+export declare function renderConfigFileMarkdown(sections: ConfigFileSection[], options?: RenderConfigFileOptions): string;
+//#endregion

package/dist/packages/config/src/generators/markdown.js

@@ -0,0 +1,27 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{titleCase as t}from"../../../shared/src/string-utils.js";import"../../../shared/src/index.js";import{splitBaseSchema as n,zodToJsonSchema as r}from"../schema.js";import{collectEnvVars as i}from"../collect.js";import{cliFlagLabel as a}from"./cli.js";import o from"node:fs";function s(e,t,n,r){let i=[`${n} ${t}`];return e.type===`object`&&e.properties?(i.push(...c(e,`${n}#`,r)),i):(e.env&&i.push(`- **Env**: \`${e.env}\``),i.push(`- **Type**: \`${e.tsType??(Array.isArray(e.type)?e.type.join(` | `):e.type)??`any`}\``),e.default!==void 0&&i.push(`- **Default**: \`${JSON.stringify(e.default)}\``),e.description&&i.push(``,e.description),i)}function c(e,t,n){let r=[];for(let[i,o]of Object.entries(e.properties??{})){let e=n.useFlags&&o.env?a(o.env,n):`\`${i}\``;r.push(``,...s(o,e,t,n))}return r}function l(e,r,i={}){let a=i.outline??[2,3,4],o={useFlags:e===(i.cliScope??`cli`),baseGroup:i.baseGroup??`base`,...i.envPrefix?{envPrefix:i.envPrefix}:{},...i.shortFlags?{shortFlags:i.shortFlags}:{}},{base:s,groups:l}=n(r,o.baseGroup),u=[`---`,`title: ${t(e)} Configuration`,`outline: ${JSON.stringify(a)}`,`---`,``,`# ${t(e)} Configuration`,``,`Every setting below is configured through an environment variable.`,``,`## Base`,``,...c(s,`###`,o)];for(let[e,n]of Object.entries(l.properties??{}))u.push(``,`## ${t(e)}`,``,...c(n,`###`,o));return`${u.join(`
+`).trim()}\n`}function u(e){return e===void 0?`—`:Array.isArray(e)?`\`${e.join(`,`)}\``:typeof e==`object`?`\`${JSON.stringify(e)}\``:`\`${String(e)}\``}function d(e,t,n){for(let r of Object.values(e.properties??{})){let e=r;if(e.type===`object`&&e.properties)d(r,t,n);else if(e.env){let r=e.envDefault??e.default;n.push({name:e.env,scope:t,...e.description?{description:e.description}:{},...r===void 0?{}:{default:r},...e.required===!0?{required:!0}:{},...e.secret?{secret:!0}:{},...e.public?{public:!0}:{}})}}}function f(e,t={}){let a=t.outline??[2,3,4],o=t.baseGroup??`base`,s=t.labels??{},c=[],l=[];for(let[t,i]of Object.entries(e)){let e=i.jsonSchema??r(i.zodSchema);d(n(e,o).base,t,l)}for(let n of i(e,t.envPrefix??`APP_`,{envPathOf:t.envPathOf}))n.required&&c.push({name:n.name,scope:n.scope,...n.description?{description:n.description}:{},...n.default===void 0?{}:{default:n.default}});let f=e=>[`| Variable | Default | Description |`,`| -------- | ------- | ----------- |`,...e.map(e=>`| \`${e.name}\` | ${u(e.default)} | ${(e.description??``).replace(/\n/g,` `).replace(/\|/g,`\\|`)} |`)].join(`
+`),p=s.title??`Environment variables`,m=t.intro??`Environment variables are prefixed with \`${t.envPrefix??`APP_`}\`.
+The underscore is a path separator, so every config value has an environment
+variable equivalent.`,h=t.requiredNote??`These variables have no safe default and **must** be set:`,g=t.coreNote??`The core (base) config values:`,_=t.references&&t.references.length?`\n## References\n\n${t.references.map(e=>`- [${e.label}](${e.href})`).join(`
+`)}\n`:``;return`---
+title: ${p}
+outline: ${JSON.stringify(a)}
+---
+
+# ${p}
+
+${m}
+
+## ${s.required??`Required`}
+
+${h}
+
+${f(c)}
+
+## ${s.core??`Core`}
+
+${g}
+
+${f(l)}
+${_}`}function p(t,n){let i=n.outline??[2,3,4],a=Object.entries(t).map(([t,a])=>[e.resolve(n.outDir,`${t}.md`),l(t,a.jsonSchema??r(a.zodSchema),{...n,outline:i})]);a.push([e.resolve(n.outDir,n.indexFilename??`index.md`),f(t,{...n,outline:i})]);for(let[t,n]of a)o.mkdirSync(e.dirname(t),{recursive:!0}),o.writeFileSync(t,n,`utf-8`);return a.map(([e])=>e)}function m(e,t={}){let n={baseGroup:`base`},i=t.title??`Configuration`,a=[`---`,`title: ${i}`,`outline: ${JSON.stringify(t.outline??[2,3,4])}`,`---`,``,`# ${i}`,``];t.intro&&a.push(t.intro,``);for(let t of e){a.push(`## \`${t.key}\``,``),t.description&&a.push(t.description,``);let e=r(t.schema);a.push(...c(e,`###`,n),``)}return`${a.join(`
+`).trim()}\n`}export{p as generateConfigMarkdown,m as renderConfigFileMarkdown,f as renderConfigIndex,l as renderScopeMarkdown};

package/dist/packages/config/src/generators/types.d.ts

@@ -0,0 +1,32 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ConfigScopes } from "../types.js";
+import { Schema } from "untyped";
+//#region packages/config/src/generators/types.d.ts
+export interface GenerateTypesOptions {
+  /** Output directory. When omitted, nothing is written. */
+  outputDir?: string;
+  /** The base group hoisted into `<Name>Base` (default `base`). */
+  baseGroup?: string;
+  /**
+   * Per-scope main interface name. Defaults to `<PascalScope>Config`.
+   */
+  interfaceNames?: Record<string, string>;
+  /** Per-scope extra aliases appended after the generated interface. */
+  aliases?: Record<string, string>;
+  /** File extension for generated files (default `ts`). */
+  extension?: string;
+  /** A raw (verbatim) header prepended to every generated file. */
+  header?: string;
+}
+/** The resolved schema for a scope (from a precomputed schema or the Zod one). */
+export declare function resolveScopeSchema(schema: Schema | undefined, zodSchema: unknown): Schema;
+/** Render the generated type file content for one scope. */
+export declare function renderConfigTypes(scopeName: string, schema: Schema, options?: GenerateTypesOptions): string;
+/** Render every config type file, keyed by scope name. */
+export declare function renderAllConfigTypes(scopes: ConfigScopes, options?: GenerateTypesOptions): Record<string, string>;
+/** Generate the config type files into `outputDir`. Returns the paths written. */
+export declare function generateConfigTypes(scopes: ConfigScopes, options: GenerateTypesOptions & {
+  outputDir: string;
+}): string[];
+//#endregion

package/dist/packages/config/src/generators/types.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{pascalCase as t}from"../../../shared/src/string-utils.js";import"../../../shared/src/index.js";import{splitBaseSchema as n,zodToJsonSchema as r}from"../schema.js";import i from"node:fs";import{generateTypes as a}from"untyped";const o={addExport:!0,partial:!0};function s(e,t){return e??r(t)}function c(e,r,i={}){let s=i.baseGroup??`base`,c=i.interfaceNames?.[e]??`${t(e)}Config`,l=i.aliases?.[e]??``,{base:u,groups:d,hasBase:f}=n(r,s),p=Object.keys(d.properties??{}),m=a(u,{...o,interfaceName:`${c}Base`}),h;h=f&&p.length>0?a(d,{...o,interfaceName:c}).replace(`export interface ${c} {`,`export interface ${c} extends ${c}Base {`):f?`export interface ${c} extends ${c}Base {}\n`:a(d,{...o,interfaceName:c});let g=`${m}\n${h}\n${l}`;return i.header?`${i.header}\n\n${g}`:g}function l(e,t={}){return Object.fromEntries(Object.entries(e).map(([e,n])=>[e,c(e,s(n.jsonSchema,n.zodSchema),t)]))}function u(t,n){let r=n.extension??`ts`,a=[];for(let[o,s]of Object.entries(l(t,n))){let t=e.join(n.outputDir,`${o}.${r}`);i.mkdirSync(e.dirname(t),{recursive:!0}),i.writeFileSync(t,s,`utf-8`),a.push(t)}return a}export{u as generateConfigTypes,l as renderAllConfigTypes,c as renderConfigTypes,s as resolveScopeSchema};

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

@@ -0,0 +1,21 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ConfigEngineOptions, ConfigScopeDef, ConfigScopes, EnvValueType, EnvVarDef, EnvVarMeta, envPathOf } from "./types.js";
+import { CollectEnvVarsOptions, DEFAULT_ENV_PREFIX, collectEnvVars, collectRequiredEnvVars } from "./collect.js";
+import { BuildConfigJsonOptions, ConfigJsonDoc, ConfigJsonEntry, buildConfigJson } from "./config-json.js";
+import { EnvFileOptions, generateEnvFile } from "./env-file.js";
+import { CliArgsOptionConfig, CliArgsParser, CliArgsResult, CliArgsValues, CliFlagOptions, CliOptionDef, GenerateCliOptionsOptions, cliFlagLabel, cliFlagOf, cliShortOf, createCliArgsParser, flagOf, generateCliArgsOptions, generateCliOptions } from "./generators/cli.js";
+import { GenerateEnvTypesOptions, generateEnv, generateEnvDts, generateEnvTypes } from "./generators/env.js";
+import { GenerateJsonSchemaOptions, generateConfigJsonSchema, generateJsonSchemaFile } from "./generators/json.js";
+import { ConfigFileSection, GenerateMarkdownOptions, RenderConfigFileOptions, RenderMarkdownOptions, generateConfigMarkdown, renderConfigFileMarkdown, renderConfigIndex, renderScopeMarkdown } from "./generators/markdown.js";
+import { GenerateTypesOptions, generateConfigTypes, renderAllConfigTypes, renderConfigTypes, resolveScopeSchema } from "./generators/types.js";
+import { ConfigEngine, createConfigEngine } from "./engine.js";
+import { EnvSource, EnvTree, applyOverrides, envBool, envInt, envList, envMap, envString, parseEnvTree, readEnvPath, trimTrailingSlashes } from "./env.js";
+import "./generators/index.js";
+import { findProjectRoot, monorepoRoot } from "./root.js";
+import { SplitSchema, compileZodSchema, envMetaOf, flattenBaseSchema, resolveUntypedSchema, splitBaseSchema, zodToJsonSchema, zodToUntypedDefinition } from "./schema.js";
+declare namespace index_d_exports {
+  export { BuildConfigJsonOptions, CliArgsOptionConfig, CliArgsParser, CliArgsResult, CliArgsValues, CliFlagOptions, CliOptionDef, CollectEnvVarsOptions, ConfigEngine, ConfigEngineOptions, ConfigFileSection, ConfigJsonDoc, ConfigJsonEntry, ConfigScopeDef, ConfigScopes, DEFAULT_ENV_PREFIX, EnvFileOptions, EnvSource, EnvTree, EnvValueType, EnvVarDef, EnvVarMeta, GenerateCliOptionsOptions, GenerateEnvTypesOptions, GenerateJsonSchemaOptions, GenerateMarkdownOptions, GenerateTypesOptions, RenderConfigFileOptions, RenderMarkdownOptions, SplitSchema, applyOverrides, buildConfigJson, cliFlagLabel, cliFlagOf, cliShortOf, collectEnvVars, collectRequiredEnvVars, compileZodSchema, createCliArgsParser, createConfigEngine, envBool, envInt, envList, envMap, envMetaOf, envPathOf, envString, findProjectRoot, flagOf, flattenBaseSchema, generateCliArgsOptions, generateCliOptions, generateConfigJsonSchema, generateConfigMarkdown, generateConfigTypes, generateEnv, generateEnvDts, generateEnvFile, generateEnvTypes, generateJsonSchemaFile, monorepoRoot, parseEnvTree, readEnvPath, renderAllConfigTypes, renderConfigFileMarkdown, renderConfigIndex, renderConfigTypes, renderScopeMarkdown, resolveScopeSchema, resolveUntypedSchema, splitBaseSchema, trimTrailingSlashes, zodToJsonSchema, zodToUntypedDefinition };
+}
+//#endregion
+export { BuildConfigJsonOptions, CliArgsOptionConfig, CliArgsParser, CliArgsResult, CliArgsValues, CliFlagOptions, CliOptionDef, CollectEnvVarsOptions, ConfigEngine, ConfigEngineOptions, ConfigFileSection, ConfigJsonDoc, ConfigJsonEntry, ConfigScopeDef, ConfigScopes, DEFAULT_ENV_PREFIX, EnvFileOptions, EnvSource, EnvTree, EnvValueType, EnvVarDef, EnvVarMeta, GenerateCliOptionsOptions, GenerateEnvTypesOptions, GenerateJsonSchemaOptions, GenerateMarkdownOptions, GenerateTypesOptions, RenderConfigFileOptions, RenderMarkdownOptions, SplitSchema, applyOverrides, buildConfigJson, cliFlagLabel, cliFlagOf, cliShortOf, collectEnvVars, collectRequiredEnvVars, compileZodSchema, createCliArgsParser, createConfigEngine, envBool, envInt, envList, envMap, envMetaOf, envPathOf, envString, findProjectRoot, flagOf, flattenBaseSchema, generateCliArgsOptions, generateCliOptions, generateConfigJsonSchema, generateConfigMarkdown, generateConfigTypes, generateEnv, generateEnvDts, generateEnvFile, generateEnvTypes, generateJsonSchemaFile, index_d_exports, monorepoRoot, parseEnvTree, readEnvPath, renderAllConfigTypes, renderConfigFileMarkdown, renderConfigIndex, renderConfigTypes, renderScopeMarkdown, resolveScopeSchema, resolveUntypedSchema, splitBaseSchema, trimTrailingSlashes, zodToJsonSchema, zodToUntypedDefinition };

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

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;import{__exportAll as e}from"../../../_virtual/_rolldown/runtime.js";import{compileZodSchema as t,envMetaOf as n,flattenBaseSchema as r,resolveUntypedSchema as i,splitBaseSchema as a,zodToJsonSchema as o,zodToUntypedDefinition as s}from"./schema.js";import{envPathOf as c}from"./types.js";import{DEFAULT_ENV_PREFIX as l,collectEnvVars as u,collectRequiredEnvVars as d}from"./collect.js";import{buildConfigJson as f}from"./config-json.js";import{generateEnvFile as p}from"./env-file.js";import{cliFlagLabel as m,cliFlagOf as h,cliShortOf as g,createCliArgsParser as _,flagOf as v,generateCliArgsOptions as y,generateCliOptions as b}from"./generators/cli.js";import{generateEnv as x,generateEnvDts as S,generateEnvTypes as C}from"./generators/env.js";import{generateConfigJsonSchema as w,generateJsonSchemaFile as T}from"./generators/json.js";import{generateConfigMarkdown as E,renderConfigFileMarkdown as D,renderConfigIndex as O,renderScopeMarkdown as k}from"./generators/markdown.js";import{generateConfigTypes as A,renderAllConfigTypes as j,renderConfigTypes as M,resolveScopeSchema as N}from"./generators/types.js";import{findProjectRoot as P,monorepoRoot as F}from"./root.js";import{createConfigEngine as I}from"./engine.js";import{applyOverrides as L,envBool as R,envInt as z,envList as B,envMap as V,envString as H,parseEnvTree as U,readEnvPath as W,trimTrailingSlashes as G}from"./env.js";import"./generators/index.js";var K=/* @__PURE__ */ e({DEFAULT_ENV_PREFIX:()=>l,applyOverrides:()=>L,buildConfigJson:()=>f,cliFlagLabel:()=>m,cliFlagOf:()=>h,cliShortOf:()=>g,collectEnvVars:()=>u,collectRequiredEnvVars:()=>d,compileZodSchema:()=>t,createCliArgsParser:()=>_,createConfigEngine:()=>I,envBool:()=>R,envInt:()=>z,envList:()=>B,envMap:()=>V,envMetaOf:()=>n,envPathOf:()=>c,envString:()=>H,findProjectRoot:()=>P,flagOf:()=>v,flattenBaseSchema:()=>r,generateCliArgsOptions:()=>y,generateCliOptions:()=>b,generateConfigJsonSchema:()=>w,generateConfigMarkdown:()=>E,generateConfigTypes:()=>A,generateEnv:()=>x,generateEnvDts:()=>S,generateEnvFile:()=>p,generateEnvTypes:()=>C,generateJsonSchemaFile:()=>T,monorepoRoot:()=>F,parseEnvTree:()=>U,readEnvPath:()=>W,renderAllConfigTypes:()=>j,renderConfigFileMarkdown:()=>D,renderConfigIndex:()=>O,renderConfigTypes:()=>M,renderScopeMarkdown:()=>k,resolveScopeSchema:()=>N,resolveUntypedSchema:()=>i,splitBaseSchema:()=>a,trimTrailingSlashes:()=>G,zodToJsonSchema:()=>o,zodToUntypedDefinition:()=>s});export{l as DEFAULT_ENV_PREFIX,L as applyOverrides,f as buildConfigJson,m as cliFlagLabel,h as cliFlagOf,g as cliShortOf,u as collectEnvVars,d as collectRequiredEnvVars,t as compileZodSchema,_ as createCliArgsParser,I as createConfigEngine,R as envBool,z as envInt,B as envList,V as envMap,n as envMetaOf,c as envPathOf,H as envString,P as findProjectRoot,v as flagOf,r as flattenBaseSchema,y as generateCliArgsOptions,b as generateCliOptions,w as generateConfigJsonSchema,E as generateConfigMarkdown,A as generateConfigTypes,x as generateEnv,S as generateEnvDts,p as generateEnvFile,C as generateEnvTypes,T as generateJsonSchemaFile,F as monorepoRoot,U as parseEnvTree,W as readEnvPath,j as renderAllConfigTypes,D as renderConfigFileMarkdown,O as renderConfigIndex,M as renderConfigTypes,k as renderScopeMarkdown,N as resolveScopeSchema,i as resolveUntypedSchema,a as splitBaseSchema,K as src_exports,G as trimTrailingSlashes,o as zodToJsonSchema,s as zodToUntypedDefinition};

package/dist/packages/config/src/root.d.ts

@@ -0,0 +1,11 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+//#region packages/config/src/root.d.ts
+/**
+ * Walk up from a starting directory until a `package.json` is found. Falls back
+ * to the module's own directory when nothing matches.
+ */
+export declare function findProjectRoot(start?: string): string;
+/** Resolve the monorepo root from a module location by walking up. */
+export declare function monorepoRoot(from?: string): string;
+//#endregion

package/dist/packages/config/src/root.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import{fileURLToPath as t}from"node:url";import.meta.url;import n from"node:fs";function r(r){let i=r??e.dirname(t(import.meta.url));for(let t=0;t<12;t++){if(n.existsSync(e.join(i,`package.json`)))return i;let t=e.resolve(i,`..`);if(t===i)break;i=t}return r??e.dirname(t(import.meta.url))}function i(e){return r(e)}export{r as findProjectRoot,i as monorepoRoot};

package/dist/packages/config/src/schema.d.ts

@@ -0,0 +1,34 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { EnvVarMeta } from "./types.js";
+import { ZodType } from "zod";
+import { Schema } from "untyped";
+//#region packages/config/src/schema.d.ts
+/** Read the env metadata attached to a Zod leaf via `.meta()`. */
+export declare function envMetaOf(schema: ZodType): EnvVarMeta | undefined;
+/** Lower a Zod config schema into an untyped definition object. */
+export declare function zodToUntypedDefinition(zodSchema: ZodType): Record<string, unknown>;
+/** Compile a Zod schema to a fast native parse function, falling back on error. */
+export declare function compileZodSchema<T extends ZodType>(schema: T): T;
+/**
+ * Resolve an untyped definition into a `Schema`, mirroring untyped's
+ * `resolveSchema` synchronously.
+ */
+export declare function resolveUntypedSchema(input: Record<string, unknown>): Schema;
+/** Build the resolved untyped JSON Schema directly from a Zod config schema. */
+export declare function zodToJsonSchema(zodSchema: ZodType): Schema;
+/** A resolved untyped schema split into its base group and the remaining groups. */
+export interface SplitSchema {
+  base: Schema;
+  groups: Schema;
+  hasBase: boolean;
+}
+/**
+ * Split a resolved untyped schema into its base group (flat config fields) and
+ * the remaining nested groups. Schemas without the base property treat the whole
+ * schema as the base group.
+ */
+export declare function splitBaseSchema(schema: Schema, baseGroup?: string): SplitSchema;
+/** Flatten the base group of a resolved schema into the top level. */
+export declare function flattenBaseSchema(schema: Schema, baseGroup?: string): Schema;
+//#endregion

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

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;import{z as e}from"zod";const t={string:`string`,number:`number`,integer:`number`,boolean:`boolean`,null:`null`};function n(e){let t=e.meta?.();return t&&typeof t==`object`&&`env`in t?t:void 0}function r(e){return e.enum?`string`:Array.isArray(e.type)?e.type.find(e=>e!==`null`)??`string`:e.type??`string`}function i(e){let n=typeof e?.type==`string`?e.type:`string`;return t[n]??`string`}function a(e){if(e.enum&&Array.isArray(e.enum))return`'${e.enum.join(`' | '`)}'`;let n=Array.isArray(e.type)?e.type:[e.type??`string`];return n.includes(`array`)?`Array<${i(e.items)}>`:n.includes(`object`)?`Record<string, ${i(e.additionalProperties)}>`:n.map(e=>t[e]??e).join(` | `)}function o(e,t=!1){if(e.properties){let n=t?{$schema:{tags:[`@required`]}}:{};for(let[t,r]of Object.entries(e.properties))n[t]=o(r,e.required?.includes(t)??!1);return n}let n={};return e.defaultValue===void 0?e.default!==void 0&&(n.$default=e.default):n.$default=e.defaultValue,n.$schema={type:r(e),tsType:a(e),...r(e)===`array`?{items:{type:i(e.items)}}:{},...t?{tags:[`@required`]}:{},...e.description?{description:e.description}:{},...e.env?{env:e.env}:{},...e.scope?{scope:e.scope}:{},...e.secret?{secret:!0}:{},...e.public?{public:!0}:{},...e.required===!0?{required:!0}:{},...e.defaultValue!==void 0&&e.default!==void 0?{envDefault:e.default}:{}},n}function s(e){return o(e.toJSONSchema())}function c(t){try{return e.compile(t)}catch{return t}}function l(e){return e!==null&&!Array.isArray(e)&&typeof e==`object`}function u(e){let t=typeof e;if(t!==`undefined`&&e!==null)return Array.isArray(e)?`array`:t}function d(e,t,n=`.`){return e?`${e}${n}${t}`:t}function f(e){return[...new Set(e.filter(e=>!!e))]}function p(e){if(e.type===`array`&&!(`items`in e)){let t=f((e.default??[]).map(e=>u(e)));e.items={type:t.length===0?`any`:t.length===1?t[0]:t}}if(e.default===void 0&&(`properties`in e||e.type===`object`||e.type===`any`)){let t=e.properties??{};e.default=Object.fromEntries(Object.entries(t).filter(([,e])=>`default`in e).map(([e,t])=>[e,t.default]))}}function m(e,t,n){if(n.cache.has(t))return n.cache.get(t);let r=`#${t.replace(/\./g,`/`)}`;if(!l(e)){let i=Array.isArray(e)?[...e]:e,a={type:u(e),id:r,default:i};return p(a),n.cache.set(t,a),a}let i={...e.$schema??{},id:r};n.cache.set(t,i);let a=Object.keys(e).filter(e=>e!==`$resolve`&&e!==`$schema`&&e!==`$default`);if(a.length>0){let r={};i.properties=r;for(let o of a)if(!r[o]){let a=r[o]=m(e[o],d(t,o),n);Array.isArray(a.tags)&&a.tags.includes(`@required`)&&(i.required=i.required||[],i.required.includes(o)||i.required.push(o))}}return i.default===void 0&&`$default`in e&&(i.default=e.$default),i.type||=u(i.default)||(i.properties?`object`:`any`),p(i),i}function h(e){return m(e,``,{root:e,cache:/* @__PURE__ */ new Map})}function g(e){return h(s(e))}function _(e,t=`base`){let n=e.properties??{},r=n[t];if(r&&r.type===`object`&&r.properties){let{[t]:i,...a}=n,o=(e.required??[]).filter(e=>e!==t);return{base:r,groups:{...e,properties:a,...o.length>0?{required:o}:{}},hasBase:!0}}return{base:e,groups:{...e,properties:{}},hasBase:!1}}function v(e,t=`base`){let n=e.properties??{},r=n[t];if(r?.type!==`object`)return e;let i=r.properties;if(!i)return e;let{[t]:a,...o}=n;return{...e,properties:{...i,...o},required:[...(e.required??[]).filter(e=>e!==t),...r.required??[]]}}export{c as compileZodSchema,n as envMetaOf,v as flattenBaseSchema,h as resolveUntypedSchema,_ as splitBaseSchema,g as zodToJsonSchema,s as zodToUntypedDefinition};

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

@@ -0,0 +1,75 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ZodType } from "zod";
+import { Schema } from "untyped";
+//#region packages/config/src/types.d.ts
+/** The value type an env var resolves to. */
+export type EnvValueType = 'string' | 'number' | 'boolean' | 'array' | 'object';
+/**
+ * The metadata a consumer attaches to a Zod leaf via `.meta()` to describe the
+ * environment variable that backs a configuration value.
+ */
+export interface EnvVarMeta {
+  /** The env var name, e.g. `MYAPP_AUTH_PASSWORD`. */
+  env: string;
+  /** The dotted config path, e.g. `auth.password`. */
+  path?: string;
+  /** Human-readable description (used by `.env.example` + the docs). */
+  description?: string;
+  /** Whether the var has no safe default and must be set. */
+  required?: boolean;
+  /** Whether the value is a secret (never emitted/logged). */
+  secret?: boolean;
+  /** The scope the variable belongs to. */
+  scope?: string;
+  /** Whether the variable is safe to expose to the browser (frontend). */
+  public?: boolean;
+  /**
+   * The resolved-config default, when it differs from the raw env default
+   * (e.g. the positive field behind a negative-named env flag).
+   */
+  defaultValue?: unknown;
+}
+/** A collected env-var definition. */
+export interface EnvVarDef {
+  name: string;
+  path: string;
+  description?: string;
+  default?: unknown;
+  required?: boolean;
+  secret?: boolean;
+  public?: boolean;
+  scope: string;
+  envType?: EnvValueType;
+}
+/** One configuration scope: its Zod schema and an optional resolved schema. */
+export interface ConfigScopeDef {
+  /** The Zod schema (the single source of truth). */
+  zodSchema: ZodType;
+  /** A pre-resolved untyped schema (resolved from the Zod schema if omitted). */
+  jsonSchema?: Schema;
+}
+/** The scopes registered with an engine, keyed by scope name. */
+export type ConfigScopes = Record<string, ConfigScopeDef>;
+/** Options shared by every generator. */
+export interface ConfigEngineOptions {
+  /** The scopes to walk, keyed by scope name (eg. `{ server, frontend, cli }`). */
+  scopes: ConfigScopes;
+  /** The env-var prefix (eg. `MYAPP_`). Kept as a replacement token in code. */
+  envPrefix?: string;
+  /**
+   * The object key that holds the "flat" base config fields, hoisted out of
+   * the nested groups in the generated types/docs (default `base`).
+   */
+  baseGroup?: string;
+  /** The monorepo/project root used for default output paths. */
+  root?: string;
+  /**
+   * Custom env-name -> dotted-path derivation for leaves without an explicit
+   * `path` (eg. to handle dual `PREFIX_`/`VITE_` prefixes).
+   */
+  envPathOf?: (env: string) => string;
+}
+/** Derive the dotted config path from an env var name + prefix. */
+export declare function envPathOf(env: string, prefix?: string): string;
+//#endregion

package/dist/packages/config/src/types.js

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;function e(e,t=`APP_`){return e.slice(e.startsWith(t)?t.length:0).toLowerCase().replace(/_/g,`.`)}export{e as envPathOf};

package/dist/packages/core/src/graph.d.ts

@@ -0,0 +1,55 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+//#region packages/core/src/graph.d.ts
+/** Directory names never descended into during discovery. */
+export declare const IGNORED_DIRS: Set<string>;
+/** The package managers a lock file can indicate. */
+export type PackageManager = 'yarn' | 'npm' | 'pnpm' | 'bun';
+/** One discovered package (a `package.json` and/or a dbx config directory). */
+export interface ProjectNode {
+  /** The package name (from `package.json`). */
+  name?: string;
+  /** Directory relative to the graph root (posix). */
+  dir: string;
+  /** Whether the directory contains a `dbx.config.*` file. */
+  hasConfig: boolean;
+  /** The dbx config path relative to the root (when present). */
+  config?: string;
+  /** Names of the other discovered projects this one depends on. */
+  dependencies: string[];
+}
+/** The project dependency graph written to `.dbx/toolchain/projects.json`. */
+export interface ProjectGraph {
+  root: string;
+  packageManager?: PackageManager;
+  generatedAt: string;
+  /** Every discovered package. */
+  projects: ProjectNode[];
+  /** The subset with a dbx config (what the tooling syncs). */
+  dbxProjects: ProjectNode[];
+  /** Dbx project dirs (relative) in dependency order (dependencies first). */
+  order: string[];
+}
+export interface BuildProjectGraphOptions {
+  /** Maximum directory depth to descend (default 5). */
+  maxDepth?: number;
+}
+/** Detect the package manager from the lock file present at the root. */
+export declare function detectPackageManager(root: string): PackageManager | undefined;
+/**
+ * Recursively discover projects under `root` and build their dependency graph.
+ * Skips `node_modules`, `.dbx/toolchain` and other common/generated directories.
+ */
+export declare function buildProjectGraph(root: string, options?: BuildProjectGraphOptions): ProjectGraph;
+/**
+ * Topologically order dbx projects so a dependency is always synced before its
+ * dependents. Cycles (or missing edges) fall back to the input order.
+ */
+export declare function orderProjects(dbxProjects: ProjectNode[]): string[];
+/** The path of the generated project graph for a root. */
+export declare function projectGraphPath(root: string): string;
+/** Write the project graph to `<root>/.dbx/toolchain/projects.json`. */
+export declare function writeProjectGraph(root: string, graph?: ProjectGraph): string;
+/** Read the project graph for a root, or `undefined` when it does not exist. */
+export declare function readProjectGraph(root: string): ProjectGraph | undefined;
+//#endregion

package/dist/packages/core/src/graph.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{readJsonAt as t,toJson as n}from"../../shared/src/fs-utils.js";import"../../shared/src/index.js";import{findConfigFile as r}from"./loader.js";import i from"node:fs";const a=/* @__PURE__ */ new Set([`node_modules`,`dist`,`build`,`out`,`coverage`,`tmp`,`temp`,`vendor`,`jspm_packages`,`web_modules`]);function o(e){return e.startsWith(`.`)||a.has(e)}function s(t){try{return i.readdirSync(t,{withFileTypes:!0}).filter(e=>e.isDirectory()&&!o(e.name)).map(n=>e.join(t,n.name))}catch{return[]}}function c(t,n){return e.relative(t,n).replace(/\\/g,`/`)||`.`}function l(t){let n=n=>i.existsSync(e.join(t,n));if(n(`yarn.lock`))return`yarn`;if(n(`pnpm-lock.yaml`))return`pnpm`;if(n(`package-lock.json`))return`npm`;if(n(`bun.lock`)||n(`bun.lockb`))return`bun`}const u=[`dependencies`,`devDependencies`,`peerDependencies`,`optionalDependencies`];function d(e,n={}){let i=n.maxDepth??5,a=/* @__PURE__ */ new Map,o=/* @__PURE__ */ new Map,d=(n,l)=>{let u=t(n,`package.json`),f=r(n);if(u||f){let t={...u?.name?{name:u.name}:{},dir:c(e,n),hasConfig:!!f,...f?{config:c(e,f)}:{},dependencies:[]};a.set(n,t),u?.name&&o.set(u.name,n)}if(!(l>=i))for(let e of s(n))d(e,l+1)};d(e,0);for(let[e,n]of a){let r=t(e,`package.json`);if(!r)continue;let i=/* @__PURE__ */ new Set;for(let t of u){let n=r[t];if(n&&typeof n==`object`)for(let t of Object.keys(n)){let n=o.get(t);n&&n!==e&&i.add(t)}}n.dependencies=[...i].sort()}let p=[...a.values()].sort((e,t)=>e.dir.localeCompare(t.dir)),m=p.filter(e=>e.hasConfig);return{root:e,packageManager:l(e),generatedAt:(/* @__PURE__ */ new Date()).toISOString(),projects:p,dbxProjects:m,order:f(m)}}function f(e){let t=/* @__PURE__ */ new Map;for(let n of e)n.name&&t.set(n.name,n.dir);let n=new Map(e.map(e=>[e.dir,e])),r=/* @__PURE__ */ new Set,i=/* @__PURE__ */ new Set,a=[],o=e=>{if(r.has(e)||i.has(e))return;i.add(e);let s=n.get(e);for(let e of s?.dependencies??[]){let r=t.get(e);r&&n.has(r)&&o(r)}i.delete(e),r.add(e),a.push(e)};for(let t of e)o(t.dir);return a}function p(t){return e.join(t,`.dbx`,`toolchain`,`projects.json`)}function m(t,r){let a=p(t);return i.mkdirSync(e.dirname(a),{recursive:!0}),i.writeFileSync(a,n(r??d(t)),`utf-8`),a}function h(e){try{return JSON.parse(i.readFileSync(p(e),`utf-8`))}catch{return}}export{a as IGNORED_DIRS,d as buildProjectGraph,l as detectPackageManager,f as orderProjects,p as projectGraphPath,h as readProjectGraph,m as writeProjectGraph};

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

@@ -0,0 +1,16 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { BuildProjectGraphOptions, IGNORED_DIRS, PackageManager, ProjectGraph, ProjectNode, buildProjectGraph, detectPackageManager, orderProjects, projectGraphPath, readProjectGraph, writeProjectGraph } from "./graph.js";
+import { LoadedConfig, findConfigFile, loadToolingConfig } from "./loader.js";
+import { MANIFEST_DIR, MANIFEST_FILE, Manifest, readManifest, writeManifest } from "./manifest.js";
+import { detectProjectType, resolveProjectType } from "./project-type.js";
+import { SelectProjectsOptions, SelectedProject, selectProjects } from "./select.js";
+import { ResetProjectsOptions, ResetProjectsResult, ResetSelectors, ResetToolingOptions, ResetToolingResult, resetProjects, resetTooling } from "./reset.js";
+import { RunSyncOptions, SyncResult, runSync } from "./sync.js";
+import { VscodeSyncOptions, vscodeSyncTask } from "./vscode.js";
+import { RunWatchOptions, runWatch } from "./watch.js";
+declare namespace index_d_exports {
+  export { BuildProjectGraphOptions, IGNORED_DIRS, LoadedConfig, MANIFEST_DIR, MANIFEST_FILE, Manifest, PackageManager, ProjectGraph, ProjectNode, ResetProjectsOptions, ResetProjectsResult, ResetSelectors, ResetToolingOptions, ResetToolingResult, RunSyncOptions, RunWatchOptions, SelectProjectsOptions, SelectedProject, SyncResult, VscodeSyncOptions, buildProjectGraph, detectPackageManager, detectProjectType, findConfigFile, loadToolingConfig, orderProjects, projectGraphPath, readManifest, readProjectGraph, resetProjects, resetTooling, resolveProjectType, runSync, runWatch, selectProjects, vscodeSyncTask, writeManifest, writeProjectGraph };
+}
+//#endregion
+export { BuildProjectGraphOptions, IGNORED_DIRS, LoadedConfig, MANIFEST_DIR, MANIFEST_FILE, Manifest, PackageManager, ProjectGraph, ProjectNode, ResetProjectsOptions, ResetProjectsResult, ResetSelectors, ResetToolingOptions, ResetToolingResult, RunSyncOptions, RunWatchOptions, SelectProjectsOptions, SelectedProject, SyncResult, VscodeSyncOptions, buildProjectGraph, detectPackageManager, detectProjectType, findConfigFile, index_d_exports, loadToolingConfig, orderProjects, projectGraphPath, readManifest, readProjectGraph, resetProjects, resetTooling, resolveProjectType, runSync, runWatch, selectProjects, vscodeSyncTask, writeManifest, writeProjectGraph };

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

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;import{__exportAll as e}from"../../../_virtual/_rolldown/runtime.js";import{detectProjectType as t,resolveProjectType as n}from"./project-type.js";import{findConfigFile as r,loadToolingConfig as i}from"./loader.js";import{IGNORED_DIRS as a,buildProjectGraph as o,detectPackageManager as s,orderProjects as c,projectGraphPath as l,readProjectGraph as u,writeProjectGraph as d}from"./graph.js";import{MANIFEST_DIR as f,MANIFEST_FILE as p,readManifest as m,writeManifest as h}from"./manifest.js";import{selectProjects as g}from"./select.js";import{resetProjects as _,resetTooling as v}from"./reset.js";import{runSync as y}from"./sync.js";import{vscodeSyncTask as b}from"./vscode.js";import{runWatch as x}from"./watch.js";var S=/* @__PURE__ */ e({IGNORED_DIRS:()=>a,MANIFEST_DIR:()=>f,MANIFEST_FILE:()=>p,buildProjectGraph:()=>o,detectPackageManager:()=>s,detectProjectType:()=>t,findConfigFile:()=>r,loadToolingConfig:()=>i,orderProjects:()=>c,projectGraphPath:()=>l,readManifest:()=>m,readProjectGraph:()=>u,resetProjects:()=>_,resetTooling:()=>v,resolveProjectType:()=>n,runSync:()=>y,runWatch:()=>x,selectProjects:()=>g,vscodeSyncTask:()=>b,writeManifest:()=>h,writeProjectGraph:()=>d});export{a as IGNORED_DIRS,f as MANIFEST_DIR,p as MANIFEST_FILE,o as buildProjectGraph,s as detectPackageManager,t as detectProjectType,r as findConfigFile,i as loadToolingConfig,c as orderProjects,l as projectGraphPath,m as readManifest,u as readProjectGraph,_ as resetProjects,v as resetTooling,n as resolveProjectType,y as runSync,x as runWatch,g as selectProjects,S as src_exports,b as vscodeSyncTask,h as writeManifest,d as writeProjectGraph};

package/dist/packages/core/src/loader.d.ts

@@ -0,0 +1,27 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { Replacements } from "../../shared/src/template.js";
+import { ProjectType } from "../../shared/src/config-schema.js";
+import { ToolingConfig } from "../../shared/src/toolchain.js";
+import "../../shared/src/index.js";
+//#region packages/core/src/loader.d.ts
+/** A loaded tooling config plus its resolved path + replacement tokens. */
+export interface LoadedConfig {
+  config: ToolingConfig;
+  /** The config file that was loaded (undefined when none was found). */
+  path?: string;
+  tokens: Replacements;
+  /** The resolved project kind. */
+  projectType: ProjectType;
+}
+/** Find the first `dbx.config.*` file at `cwd`, if any. */
+export declare function findConfigFile(cwd?: string): string | undefined;
+/**
+ * Load the tooling config for a project. A `dbx.config.*` file exports
+ * `{ toolchain: { ...sections } }`; the `toolchain` value is unwrapped here so
+ * the rest of the toolchain works with flat sections. When no config file (or no
+ * `toolchain` key) exists an empty config is returned (so every task falls back
+ * to its defaults).
+ */
+export declare function loadToolingConfig(cwd?: string): Promise<LoadedConfig>;
+//#endregion

package/dist/packages/core/src/loader.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import{pathToFileURL as t}from"node:url";import.meta.url;import{CONFIG_FILE_NAMES as n,resolveTokens as r}from"../../shared/src/toolchain.js";import"../../shared/src/index.js";import{resolveProjectType as i}from"./project-type.js";import a from"node:fs";function o(t=process.cwd()){for(let r of n){let n=e.resolve(t,r);if(a.existsSync(n))return n}}async function s(e){if(e.endsWith(`.json`))return JSON.parse(a.readFileSync(e,`utf-8`));let n=t(e).href;try{let e=await import(n);return e.default??e}catch(e){try{let{tsImport:e}=await import(`/home/runner/work/toolchain/toolchain/node_modules/tsx/dist/esm/api/index.mjs`),t=await e(n,import.meta.url);return t.default??t}catch{throw e}}}async function c(e=process.cwd()){let t=o(e),n={};if(t){let e=await s(t),r=e&&typeof e==`object`?e.toolchain:void 0;r&&typeof r==`object`&&(n=r)}let a=r(n);return await n.hooks?.afterLoad?.({cwd:e,config:n,tokens:a,...t?{path:t}:{}}),{config:n,...t?{path:t}:{},tokens:a,projectType:i(e,n)}}export{o as findConfigFile,c as loadToolingConfig};

package/dist/packages/core/src/manifest.d.ts

@@ -0,0 +1,17 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+//#region packages/core/src/manifest.d.ts
+/** The manifest directory + file recording every file the tooling manages. */
+export declare const MANIFEST_DIR = ".dbx/toolchain";
+export declare const MANIFEST_FILE = "manifest.json";
+export interface Manifest {
+  /** Repo-relative paths of every generated/managed file. */
+  files: string[];
+  /** ISO timestamp of the last successful sync (absent when never synced). */
+  syncedAt?: string;
+}
+/** Read the manifest (`{ files: [] }` when missing/invalid). */
+export declare function readManifest(cwd: string): Manifest;
+/** Write the manifest, creating the directory as needed. */
+export declare function writeManifest(cwd: string, files: string[], syncedAt?: string): void;
+//#endregion

package/dist/packages/core/src/manifest.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{toJson as t}from"../../shared/src/fs-utils.js";import"../../shared/src/index.js";import n from"node:fs";const r=`.dbx/toolchain`,i=`manifest.json`;function a(t){let a=e.resolve(t,r,i);try{let e=JSON.parse(n.readFileSync(a,`utf-8`));return{files:Array.isArray(e.files)?e.files:[],...typeof e.syncedAt==`string`?{syncedAt:e.syncedAt}:{}}}catch{return{files:[]}}}function o(a,o,s){let c=e.resolve(a,r,i);n.mkdirSync(e.dirname(c),{recursive:!0}),n.writeFileSync(c,t({files:[...new Set(o)].sort(),syncedAt:s??(/* @__PURE__ */ new Date()).toISOString()}),`utf-8`)}export{r as MANIFEST_DIR,i as MANIFEST_FILE,a as readManifest,o as writeManifest};

package/dist/packages/core/src/project-type.d.ts

@@ -0,0 +1,14 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ProjectType } from "../../shared/src/config-schema.js";
+import { ToolingConfig } from "../../shared/src/toolchain.js";
+import "../../shared/src/index.js";
+//#region packages/core/src/project-type.d.ts
+/**
+ * Resolve the project kind: an explicit `project.type` in the config wins,
+ * otherwise it is detected from the filesystem.
+ */
+export declare function resolveProjectType(cwd: string, config?: ToolingConfig): ProjectType;
+/** Detect the project kind from `cwd` (workspaces / monorepo file heuristics). */
+export declare function detectProjectType(cwd: string): ProjectType;
+//#endregion

package/dist/packages/core/src/project-type.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{readJsonAt as t}from"../../shared/src/fs-utils.js";import"../../shared/src/index.js";import n from"node:fs";function r(e,t={}){return t.project?.type?t.project.type:i(e)}function i(r){let i=t(r,`package.json`)?.workspaces;return(Array.isArray(i)?i.length>0:i&&Array.isArray(i.packages)&&i.packages.length>0)||n.existsSync(e.join(r,`tsconfig.monorepo.json`))?`monorepo-root`:n.existsSync(e.join(r,`tsconfig.default.json`))?`monorepo-workspace`:`project`}export{i as detectProjectType,r as resolveProjectType};

package/dist/packages/core/src/reset.d.ts

@@ -0,0 +1,51 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { SelectProjectsOptions } from "./select.js";
+//#region packages/core/src/reset.d.ts
+/** What parts of the tooling to remove for a project. */
+export interface ResetSelectors {
+  /** Remove the generated/managed files listed in the manifest. */
+  generated?: boolean;
+  /** Remove the `.dbx/toolchain` directory (manifest + graph). */
+  manifest?: boolean;
+  /** Remove the `dbx.config.*` file(s). */
+  config?: boolean;
+}
+export interface ResetToolingOptions extends ResetSelectors {
+  /** The project directory to reset. */
+  cwd: string;
+  /** Report what would be removed without deleting anything. */
+  dryRun?: boolean;
+}
+export interface ResetToolingResult {
+  /** Repo-relative paths removed (or that would be removed). */
+  removed: string[];
+  /** Whether this was a dry run. */
+  dryRun: boolean;
+}
+/**
+ * Remove the tooling artifacts from a single project: the generated files
+ * recorded in `.dbx/toolchain/manifest.json`, the `.dbx/toolchain` directory and/or
+ * the `dbx.config.*` file. With no selectors the generated files + the
+ * manifest directory are removed (the config is kept).
+ */
+export declare function resetTooling(options: ResetToolingOptions): ResetToolingResult;
+export interface ResetProjectsOptions extends ResetSelectors, Omit<SelectProjectsOptions, 'kind'> {
+  /** Apply to every discovered project under `root` (not just `root`). */
+  recursive?: boolean;
+  dryRun?: boolean;
+}
+export interface ResetProjectsResult {
+  results: {
+    dir: string;
+    rel: string;
+    removed: string[];
+  }[];
+  dryRun: boolean;
+}
+/**
+ * Reset one or many projects. When `recursive` is set every discovered project
+ * (optionally filtered by `include`/`exclude`) is reset; otherwise only `root`.
+ */
+export declare function resetProjects(options: ResetProjectsOptions): ResetProjectsResult;
+//#endregion

package/dist/packages/core/src/reset.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{findConfigFile as t}from"./loader.js";import{MANIFEST_DIR as n,readManifest as r}from"./manifest.js";import{selectProjects as i}from"./select.js";import a from"node:fs";function o(e){return e.replace(/\\/g,`/`)}function s(e){let t=e.generated!==void 0||e.manifest!==void 0||e.config!==void 0;return{generated:e.generated??!t,manifest:e.manifest??!t,config:e.config??!1}}function c(i){let{cwd:c}=i,l=i.dryRun??!1,u=s(i),d=[],f=(e,t)=>{a.existsSync(e)&&(l||a.rmSync(e,{force:!0}),d.push(t))};if(u.generated)for(let t of r(c).files)f(e.resolve(c,t),t);if(u.config){let n=t(c);n&&f(n,o(e.relative(c,n)))}if(u.manifest){let t=e.resolve(c,n);a.existsSync(t)&&(l||a.rmSync(t,{recursive:!0,force:!0}),d.push(`${n}/`))}return{removed:d,dryRun:l}}function l(e){let n=e.dryRun??!1;return{results:(e.recursive?i({root:e.root,...e.include?{include:e.include}:{},...e.exclude?{exclude:e.exclude}:{},...e.maxDepth===void 0?{}:{maxDepth:e.maxDepth}}):[{dir:e.root,rel:`.`,hasConfig:!!t(e.root)}]).map(t=>({dir:t.dir,rel:t.rel,removed:c({cwd:t.dir,...e.generated===void 0?{}:{generated:e.generated},...e.manifest===void 0?{}:{manifest:e.manifest},...e.config===void 0?{}:{config:e.config},dryRun:n}).removed})),dryRun:n}}export{l as resetProjects,c as resetTooling};

package/dist/packages/core/src/select.d.ts

@@ -0,0 +1,32 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+//#region packages/core/src/select.d.ts
+/** A project selected by {@link selectProjects}. */
+export interface SelectedProject {
+  /** Absolute project directory. */
+  dir: string;
+  /** Directory relative to the root (posix). */
+  rel: string;
+  /** Package name when available. */
+  name?: string;
+  /** Whether the directory has a `dbx.config.*`. */
+  hasConfig: boolean;
+}
+export interface SelectProjectsOptions {
+  /** Root to scan. */
+  root: string;
+  /** Keep only projects matching one of these patterns (glob or substring). */
+  include?: string[];
+  /** Drop projects matching any of these patterns (glob or substring). */
+  exclude?: string[];
+  /**
+   * What to keep: `all` (default), `configured` (has a dbx config) or
+   * `unconfigured` (missing a dbx config).
+   */
+  kind?: 'all' | 'configured' | 'unconfigured';
+  /** Maximum directory depth to scan (default 5). */
+  maxDepth?: number;
+}
+/** Discover projects under a root, applying include/exclude + kind filters. */
+export declare function selectProjects(options: SelectProjectsOptions): SelectedProject[];
+//#endregion

package/dist/packages/core/src/select.js

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{buildProjectGraph as t}from"./graph.js";const n=/[*?[\]{}]/,r=`<<dbx-globstar>>`;function i(e){let t=e.replace(/[.+^${}()|\\]/g,`\\$&`).replace(/\*\*/g,r).replace(/\*/g,`[^/]*`).replaceAll(r,`.*`).replace(/\?/g,`.`);return RegExp(`^${t}$`,`i`)}function a(t,r){let a=[t.rel,t.name??``,e.basename(t.rel)];if(n.test(r)){let e=i(r);return a.some(t=>e.test(t))}let o=r.toLowerCase();return a.some(e=>e.toLowerCase().includes(o))}function o(n){let r=t(n.root,n.maxDepth===void 0?{}:{maxDepth:n.maxDepth}).projects.map(t=>({dir:e.resolve(n.root,t.dir),rel:t.dir,...t.name?{name:t.name}:{},hasConfig:t.hasConfig})),i=n.kind??`all`,o=n.include?.filter(Boolean)??[],s=n.exclude?.filter(Boolean)??[];return r.filter(e=>!(i===`configured`&&!e.hasConfig||i===`unconfigured`&&e.hasConfig||o.length>0&&!o.some(t=>a(e,t))||s.some(t=>a(e,t))))}export{o as selectProjects};