@deltabox/toolchain 0.0.0-stage → 1.0.7

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

@@ -0,0 +1,56 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ConfigEngineOptions, ConfigScopes, EnvVarDef } from "./types.js";
+import { BuildConfigJsonOptions, ConfigJsonDoc } from "./config-json.js";
+import { EnvFileOptions } from "./env-file.js";
+import { CliOptionDef, GenerateCliOptionsOptions } from "./generators/cli.js";
+import { GenerateEnvTypesOptions } from "./generators/env.js";
+import { GenerateJsonSchemaOptions } from "./generators/json.js";
+import { GenerateMarkdownOptions } from "./generators/markdown.js";
+import { GenerateTypesOptions } from "./generators/types.js";
+//#region packages/config/src/engine.d.ts
+/** The bound, reusable config engine. */
+export interface ConfigEngine {
+  readonly scopes: ConfigScopes;
+  readonly envPrefix: string;
+  readonly baseGroup: string;
+  readonly root: string;
+  /** Every env-var-backed leaf across the registered scopes. */
+  collectEnvVars(): EnvVarDef[];
+  /** The names of the required env vars for a scope. */
+  requiredEnvVars(scope: string): string[];
+  /** Render `.env` content. */
+  renderEnvFile(options?: EnvFileOptions): string;
+  /** Write a `.env` file. Returns the path written. */
+  writeEnvFile(options: EnvFileOptions & {
+    output: string;
+  }): string;
+  /** Build the config metadata JSON document. */
+  buildConfigJson(options?: BuildConfigJsonOptions): ConfigJsonDoc;
+  /** Build (and optionally write) the untyped JSON Schema document. */
+  generateJsonSchema(options?: GenerateJsonSchemaOptions): Promise<Record<string, unknown>>;
+  /** Write the JSON Schema document. Returns the path written. */
+  writeJsonSchema(options: GenerateJsonSchemaOptions & {
+    output: string;
+  }): Promise<string>;
+  /** Render every config type file, keyed by scope name. */
+  renderConfigTypes(options?: GenerateTypesOptions): Record<string, string>;
+  /** Write the config type files into `outputDir`. */
+  writeConfigTypes(options: GenerateTypesOptions & {
+    outputDir: string;
+  }): string[];
+  /** Write the env type files into `outputDir`. */
+  writeEnvTypes(options: GenerateEnvTypesOptions & {
+    outputDir: string;
+  }): string[];
+  /** Write the markdown reference into `outDir`. */
+  writeMarkdown(options: GenerateMarkdownOptions & {
+    outDir: string;
+  }): string[];
+  /** Generate (and optionally write) the CLI option definitions. */
+  generateCliOptions(options?: GenerateCliOptionsOptions): CliOptionDef[];
+}
+/** Create a reusable config engine. */
+export declare function createConfigEngine(options: ConfigEngineOptions): ConfigEngine;
+//#endregion
+export type { ConfigEngineOptions, ConfigScopes };

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

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{collectEnvVars as t,collectRequiredEnvVars as n}from"./collect.js";import{buildConfigJson as r}from"./config-json.js";import{generateEnvFile as i}from"./env-file.js";import{generateCliOptions as a}from"./generators/cli.js";import{generateEnvTypes as o}from"./generators/env.js";import{generateConfigJsonSchema as s,generateJsonSchemaFile as c}from"./generators/json.js";import{generateConfigMarkdown as l}from"./generators/markdown.js";import{generateConfigTypes as u,renderAllConfigTypes as d}from"./generators/types.js";import{findProjectRoot as f}from"./root.js";import p from"node:fs";function m(m){let h=m.scopes,g=m.envPrefix??`APP_`,_=m.baseGroup??`base`,v=m.root??f(),y=m.envPathOf;return{scopes:h,envPrefix:g,baseGroup:_,root:v,collectEnvVars:()=>t(h,g,{envPathOf:y}),requiredEnvVars:e=>n(h,e,g,{envPathOf:y}),renderEnvFile:(e={})=>i(h,{envPrefix:g,envPathOf:y,...e}),writeEnvFile:t=>{let n=i(h,{envPrefix:g,envPathOf:y,...t});return p.mkdirSync(e.dirname(t.output),{recursive:!0}),p.writeFileSync(t.output,n,`utf-8`),t.output},buildConfigJson:(e={})=>r(h,{envPrefix:g,envPathOf:y,...e}),generateJsonSchema:(e={})=>s(h,{baseGroup:_,...e}),writeJsonSchema:e=>c(h,{baseGroup:_,...e}),renderConfigTypes:(e={})=>d(h,{baseGroup:_,...e}),writeConfigTypes:e=>u(h,{baseGroup:_,...e}),writeEnvTypes:e=>o(h,{envPrefix:g,envPathOf:y,...e}),writeMarkdown:e=>l(h,{baseGroup:_,envPrefix:g,envPathOf:y,...e}),generateCliOptions:(e={})=>a(h,{envPrefix:g,envPathOf:y,...e})}}export{m as createConfigEngine};

package/dist/packages/config/src/env-file.d.ts

@@ -0,0 +1,33 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ConfigScopes } from "./types.js";
+import { CollectEnvVarsOptions } from "./collect.js";
+//#region packages/config/src/env-file.d.ts
+export interface EnvFileOptions {
+  /** Env vars to include (defaults to all). */
+  include?: string[];
+  /** Env vars to exclude. */
+  exclude?: string[];
+  /** Default values to inject (overrides the schema defaults). */
+  values?: Record<string, string>;
+  /** Comment banner placed at the top of the file. */
+  header?: string;
+  /** Only emit these scopes (defaults to every registered scope). */
+  scopes?: string[];
+  /** The env-var prefix (default `APP_`). */
+  envPrefix?: string;
+  /** Omit descriptions (emit bare assignments). */
+  bare?: boolean;
+  /** Extra raw `NAME=value` lines appended after the schema vars. */
+  extra?: Record<string, string>;
+  /** The characters wrapping a scope's section header (default `----`). */
+  scopeSeparator?: string;
+  /** Custom env-name -> dotted-path derivation. */
+  envPathOf?: CollectEnvVarsOptions['envPathOf'];
+}
+/**
+ * Generate `.env` content from the config schemas. Secrets and required-without-
+ * default vars are emitted blank so operators fill them in.
+ */
+export declare function generateEnvFile(scopes: ConfigScopes, options?: EnvFileOptions): string;
+//#endregion

package/dist/packages/config/src/env-file.js

@@ -0,0 +1,3 @@
+import"node:path";import"node:url";import.meta.url;import{collectEnvVars as e}from"./collect.js";function t(e){let t=e.default;return Array.isArray(t)?t.join(`,`):typeof t==`boolean`?t?`true`:`false`:typeof t==`number`?String(t):typeof t==`object`&&t?JSON.stringify(t):t===void 0?``:String(t)}function n(n,r={}){let i=r.envPrefix??`APP_`,a=r.scopeSeparator??`----`,o=e(n,i,{envPathOf:r.envPathOf}),s=r.scopes??Object.keys(n),c=o.filter(e=>s.includes(e.scope)&&(!r.include||r.include.includes(e.name))&&!r.exclude?.includes(e.name)),l=[];r.header&&l.push(r.header,``);let u;for(let e of c){if(e.scope!==u&&(u!==void 0&&l.push(``),l.push(`# ${a} ${e.scope.toUpperCase()} ${a}`),u=e.scope),!r.bare&&e.description)for(let t of e.description.split(`
+`))l.push(`# ${t}`);let n=r.values?.[e.name];e.secret&&n===void 0?l.push(`# ${e.name}=`):l.push(`${e.name}=${n??t(e)}`)}if(r.extra){let e=Object.entries(r.extra).filter(([e])=>!c.some(t=>t.name===e)).map(([e,t])=>`${e}=${t}`);e.length&&l.push(``,`# ${a} EXTRA ${a}`,...e)}return`${l.join(`
+`)}\n`}export{n as generateEnvFile};

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

@@ -0,0 +1,31 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+//#region packages/config/src/env.d.ts
+/**
+ * Low-level configuration helpers: env-tree parsing, typed accessors and
+ * override merging. Free of Node builtins so browser consumers can import the
+ * frontend resolver without pulling `node:path` / `node:url` into a bundle.
+ */
+/** A flat env source (process.env, import.meta.env or a plain object). */
+export type EnvSource = Record<string, string | undefined>;
+/** A nested tree produced by folding `PREFIX_*` vars on `_`. */
+export type EnvTree = Record<string, unknown>;
+/** Parse a flat env source into the nested `PREFIX_*` tree. */
+export declare function parseEnvTree(env?: EnvSource, prefix?: string): EnvTree;
+/** Read a dotted path out of an env tree. */
+export declare function readEnvPath(tree: EnvTree, path: string): unknown;
+/** Read a string value, falling back when unset or empty. */
+export declare function envString(tree: EnvTree, path: string, fallback?: string): string;
+/** Read an integer value, falling back when unset or not a number. */
+export declare function envInt(tree: EnvTree, path: string, fallback: number): number;
+/** Read a boolean value. Accepts true/false/1/0/yes/no/on/off. */
+export declare function envBool(tree: EnvTree, path: string, fallback: boolean): boolean;
+/** Read a comma-separated list, filtering empty entries. */
+export declare function envList(tree: EnvTree, path: string, fallback?: string[]): string[];
+/** Read `Header=value,...` into a lowercase-keyed record. */
+export declare function envMap(tree: EnvTree, path: string): Record<string, string>;
+/** Recursively merge typed overrides over a base object (shallow per level). */
+export declare function applyOverrides<T extends object>(base: T, overrides?: Partial<T>): T;
+/** Trim trailing slashes from a URL-ish string. */
+export declare function trimTrailingSlashes(value: string): string;
+//#endregion

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

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;function e(e={},t=`APP_`){let n={};for(let[r,i]of Object.entries(e)){if(!r.startsWith(t)||i===void 0)continue;let e=r.slice(t.length).toLowerCase().split(`_`),a=n;for(let t=0;t<e.length-1;t+=1){let n=e[t]??``;(typeof a[n]!=`object`||a[n]===null)&&(a[n]={}),a=a[n]}a[e[e.length-1]??``]=i}return n}function t(e,t){let n=e;for(let e of t.split(`.`)){if(typeof n!=`object`||!n)return;n=n[e]}return n}function n(e,n,r=``){let i=t(e,n);return typeof i==`string`&&i.trim()!==``?i:r}function r(e,n,r){let i=t(e,n);if(typeof i!=`string`||i.trim()===``)return r;let a=Number.parseInt(i,10);return Number.isFinite(a)?a:r}function i(e,n,r){let i=t(e,n);if(typeof i!=`string`||i.trim()===``)return r;let a=i.trim().toLowerCase();return[`true`,`1`,`yes`,`on`].includes(a)?!0:![`false`,`0`,`no`,`off`].includes(a)&&r}function a(e,n,r=[]){let i=t(e,n);return typeof i!=`string`||i.trim()===``?r:i.split(`,`).map(e=>e.trim()).filter(Boolean)}function o(e,t){let n={};for(let r of a(e,t,[])){let e=r.indexOf(`=`);e!==-1&&(n[r.slice(0,e).trim().toLowerCase()]=r.slice(e+1).trim())}return n}function s(e,t){if(!t)return e;let n={...e};for(let[r,i]of Object.entries(t)){if(i===void 0)continue;let t=e[r];n[r]=t&&typeof t==`object`&&!Array.isArray(t)&&i&&typeof i==`object`&&!Array.isArray(i)?s(t,i):i}return n}function c(e){return e.replace(/\/+$/,``)}export{s as applyOverrides,i as envBool,r as envInt,a as envList,o as envMap,n as envString,e as parseEnvTree,t as readEnvPath,c as trimTrailingSlashes};

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

@@ -0,0 +1,78 @@
+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 { ParseArgsOptionsConfig } from "node:util";
+//#region packages/config/src/generators/cli.d.ts
+/** Flag-shaping options shared by every CLI helper. */
+export interface CliFlagOptions {
+  /** The env-var prefix (default `APP_`). */
+  envPrefix?: string;
+  /** Shorthand flags keyed by env var name (eg. `{ APP_TOKEN: 't' }`). */
+  shortFlags?: Record<string, string>;
+  /** Custom env-name -> dotted-path derivation. */
+  envPathOf?: CollectEnvVarsOptions['envPathOf'];
+}
+/** A generated CLI option definition for one env var. */
+export interface CliOptionDef {
+  /** CLI flag, e.g. `--base-url`. */
+  flag: string;
+  /** Shorthand flag, e.g. `-u`. */
+  short?: string;
+  /** The env var the flag reads, e.g. `APP_CLI_BASE_URL`. */
+  env: string;
+  /** The resolved value type (`string`, `number`, `boolean`, ...). */
+  type: string;
+  /** Human-readable description. */
+  description?: string;
+  /** Never echo a real value for this option (secrets). */
+  secret?: boolean;
+  /** The resolved default value, when one is configured. */
+  default?: string;
+}
+/** The long flag name (without dashes) for an env var. */
+export declare function flagOf(env: string, options?: CliFlagOptions): string;
+/** The long flag (e.g. `--base-url`) for an env var. */
+export declare function cliFlagOf(env: string, options?: CliFlagOptions): string;
+/** The shorthand flag (e.g. `-u`) for an env var, when configured. */
+export declare function cliShortOf(env: string, options?: CliFlagOptions): string | undefined;
+/** A flag label such as `-u, --base-url`. */
+export declare function cliFlagLabel(env: string, options?: CliFlagOptions): string;
+export interface GenerateCliOptionsOptions extends CliFlagOptions {
+  /** The scope whose env vars become flags (default `cli`). */
+  scope?: string;
+  /** Output file path to write the options as JSON. */
+  output?: string;
+}
+/** Generate the CLI option definitions for a scope's env vars. */
+export declare function generateCliOptions(scopes: ConfigScopes, options?: GenerateCliOptionsOptions): CliOptionDef[];
+/** The typed `values` of a parsed CLI args result. */
+export type CliArgsValues = Record<string, string | undefined>;
+/** A parsed CLI args result (node `parseArgs` output). */
+export interface CliArgsResult {
+  values: CliArgsValues;
+  positionals: string[];
+}
+/** A generated `node:util` `parseArgs` option entry. */
+export interface CliArgsOptionConfig {
+  type: 'string';
+  short?: string;
+  default?: string;
+}
+/** Build the `options` config for `node:util`'s `parseArgs`. */
+export declare function generateCliArgsOptions(defs: CliOptionDef[]): Record<string, CliArgsOptionConfig>;
+/** A generated CLI args parser bound to a set of option definitions. */
+export interface CliArgsParser {
+  options: ParseArgsOptionsConfig;
+  parse: (args?: string[]) => CliArgsResult;
+  /** Map a parsed result into a `{ [flag]: value }` record of provided flags. */
+  toConfig: (result?: CliArgsResult) => CliArgsValues;
+}
+/**
+ * Create a CLI args parser from generated option definitions. The generated
+ * `parse` uses `node:util`'s `parseArgs` and returns a typed result.
+ */
+export declare function createCliArgsParser(defs: CliOptionDef[], parseOptions?: {
+  strict?: boolean;
+}): CliArgsParser;
+//#endregion

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

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;import{formatCliFlag as e}from"../../../shared/src/string-utils.js";import"../../../shared/src/index.js";import{collectEnvVars as t}from"../collect.js";import n from"node:fs";import{parseArgs as r}from"node:util";function i(t,n={}){return e(t,n.envPrefix??`APP_`)}function a(e,t={}){return`--${i(e,t)}`}function o(e,t={}){let n=t.shortFlags?.[e];return n?`-${n}`:void 0}function s(e,t={}){let n=a(e,t),r=o(e,t);return r?`${r}, ${n}`:n}function c(e,r={}){let i=r.scope??`cli`,s=[];for(let n of t(e,r.envPrefix,{envPathOf:r.envPathOf}).filter(e=>e.scope===i)){let e=o(n.name,r);s.push({flag:a(n.name,r),env:n.name,type:n.envType??`string`,...e?{short:e}:{},...n.description?{description:n.description}:{},...n.secret?{secret:!0}:{},...n.default!==void 0&&!n.secret?{default:String(n.default)}:{}})}return r.output&&n.writeFileSync(r.output,`${JSON.stringify(s,null,4)}\n`,`utf-8`),s}function l(e){return Object.fromEntries(e.map(e=>[e.flag.replace(/^--/,``),{type:`string`,...e.short?{short:e.short.replace(/^-/,``)}:{},...e.default?{default:e.default}:{}}]))}function u(e,t){let n=l(e);return{options:n,parse:(e=process.argv.slice(2))=>r({args:e,options:n,strict:t?.strict??!0}),toConfig:e=>{let t=e?.values??{},n={};for(let[e,r]of Object.entries(t))r!==void 0&&(n[e]=r);return n}}}export{s as cliFlagLabel,a as cliFlagOf,o as cliShortOf,u as createCliArgsParser,i as flagOf,l as generateCliArgsOptions,c as generateCliOptions};

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

@@ -0,0 +1,42 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ConfigScopes } from "../types.js";
+import { CollectEnvVarsOptions } from "../collect.js";
+//#region packages/config/src/generators/env.d.ts
+export interface GenerateEnvTypesOptions {
+  /** Output directory. When omitted, nothing is written. */
+  outputDir?: string;
+  /** The env-var prefix (default `APP_`). */
+  envPrefix?: string;
+  /** The `process.env` interface name (default `AppEnv`). */
+  envInterfaceName?: string;
+  /** The `import.meta.env` interface name (default `AppViteEnv`). */
+  viteEnvInterfaceName?: string;
+  /** The generated types file name (default `env.ts`). */
+  envFile?: string;
+  /** The generated ambient file name (default `env.d.ts`). */
+  dtsFile?: string;
+  /** The import specifier the `.d.ts` uses for the env types. */
+  importPath?: string;
+  /** A header comment prepended to both files. */
+  header?: string;
+  /** A raw (verbatim) header replacing the generated one in `env.ts`. */
+  envHeader?: string;
+  /** A raw (verbatim) header replacing the generated one in the `.d.ts`. */
+  dtsHeader?: string;
+  /** The doc comment above the `process.env` interface. */
+  envComment?: string;
+  /** Add a `declare module 'vite'` augmentation to the `.d.ts`. */
+  augmentVite?: boolean;
+  /** Custom env-name -> dotted-path derivation. */
+  envPathOf?: CollectEnvVarsOptions['envPathOf'];
+}
+/** Render the `env.ts` content (the env + vite-env interfaces). */
+export declare function generateEnv(scopes: ConfigScopes, options?: GenerateEnvTypesOptions): string;
+/** Render the ambient `.d.ts` content. */
+export declare function generateEnvDts(options?: GenerateEnvTypesOptions): string;
+/** Generate `env.ts` + the ambient `.d.ts` into `outputDir`. Returns the paths. */
+export declare function generateEnvTypes(scopes: ConfigScopes, options: GenerateEnvTypesOptions & {
+  outputDir: string;
+}): string[];
+//#endregion

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

@@ -0,0 +1,23 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{collectEnvVars as t}from"../collect.js";import n from"node:fs";function r(e){return e??`Generated env typing — DO NOT EDIT.`}function i(e,n={}){let i=n.envPrefix??`APP_`,a=n.envInterfaceName??`AppEnv`,o=n.viteEnvInterfaceName??`AppViteEnv`,s=t(e,i,{envPathOf:n.envPathOf}),c=s.filter(e=>e.scope!==`frontend`),l=s.filter(e=>e.public),u=n.envHeader?[n.envHeader,``]:[`/**`,` * ${r(n.header)}`,` */`,``];u.push(`/** ${n.envComment??"Environment variables typed on `process.env`."} */`,`export interface ${a} {`);for(let e of c)u.push(`    /** ${(e.description??``).replace(/\n/g,` `)} */`),u.push(`    ${e.name}?: string;`);u.push(`}`),u.push(``),u.push("/** Public frontend environment variables typed on `import.meta.env`. */"),u.push(`export interface ${o} {`);for(let e of l)u.push(`    /** ${(e.description??``).replace(/\n/g,` `)} */`),u.push(`    ${e.name}?: string;`);return u.push(`}`),`${u.join(`
+`).trimEnd()}\n`}function a(e={}){let t=e.envInterfaceName??`AppEnv`,n=e.viteEnvInterfaceName??`AppViteEnv`,i=e.importPath??`./env.js`;return`${e.dtsHeader?`${e.dtsHeader}\n`:`/**
+ * ${r(e.header)}
+ *
+ * Re-exports the generated env types onto \`process.env\` and
+ * \`import.meta.env\` so environment variables type-check everywhere.
+ */
+`}import type { ${t}, ${n} } from '${i}';
+
+declare global {
+    namespace NodeJS {
+        interface ProcessEnv extends ${t} {}
+    }
+
+    interface ImportMetaEnv extends ${n} {}
+}${e.augmentVite?`
+
+declare module 'vite' {
+    interface ImportMetaEnv extends ${n} {}
+}`:``}
+
+export {};
+`}function o(t,r){let o=e.join(r.outputDir,r.envFile??`env.ts`),s=e.join(r.outputDir,r.dtsFile??`env.d.ts`);return n.mkdirSync(r.outputDir,{recursive:!0}),n.writeFileSync(o,i(t,r),`utf-8`),n.writeFileSync(s,a(r),`utf-8`),[o,s]}export{i as generateEnv,a as generateEnvDts,o as generateEnvTypes};

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

@@ -0,0 +1,8 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { CliArgsOptionConfig, CliArgsParser, CliArgsResult, CliArgsValues, CliFlagOptions, CliOptionDef, GenerateCliOptionsOptions, cliFlagLabel, cliFlagOf, cliShortOf, createCliArgsParser, flagOf, generateCliArgsOptions, generateCliOptions } from "./cli.js";
+import { GenerateEnvTypesOptions, generateEnv, generateEnvDts, generateEnvTypes } from "./env.js";
+import { GenerateJsonSchemaOptions, generateConfigJsonSchema, generateJsonSchemaFile } from "./json.js";
+import { ConfigFileSection, GenerateMarkdownOptions, RenderConfigFileOptions, RenderMarkdownOptions, generateConfigMarkdown, renderConfigFileMarkdown, renderConfigIndex, renderScopeMarkdown } from "./markdown.js";
+import { GenerateTypesOptions, generateConfigTypes, renderAllConfigTypes, renderConfigTypes, resolveScopeSchema } from "./types.js";
+export { CliArgsOptionConfig, CliArgsParser, CliArgsResult, CliArgsValues, CliFlagOptions, CliOptionDef, ConfigFileSection, GenerateCliOptionsOptions, GenerateEnvTypesOptions, GenerateJsonSchemaOptions, GenerateMarkdownOptions, GenerateTypesOptions, RenderConfigFileOptions, RenderMarkdownOptions, cliFlagLabel, cliFlagOf, cliShortOf, createCliArgsParser, flagOf, generateCliArgsOptions, generateCliOptions, generateConfigJsonSchema, generateConfigMarkdown, generateConfigTypes, generateEnv, generateEnvDts, generateEnvTypes, generateJsonSchemaFile, renderAllConfigTypes, renderConfigFileMarkdown, renderConfigIndex, renderConfigTypes, renderScopeMarkdown, resolveScopeSchema };

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

@@ -0,0 +1 @@
+import"node:path";import"node:url";import.meta.url;import{cliFlagLabel as e,cliFlagOf as t,cliShortOf as n,createCliArgsParser as r,flagOf as i,generateCliArgsOptions as a,generateCliOptions as o}from"./cli.js";import{generateEnv as s,generateEnvDts as c,generateEnvTypes as l}from"./env.js";import{generateConfigJsonSchema as u,generateJsonSchemaFile as d}from"./json.js";import{generateConfigMarkdown as f,renderConfigFileMarkdown as p,renderConfigIndex as m,renderScopeMarkdown as h}from"./markdown.js";import{generateConfigTypes as g,renderAllConfigTypes as _,renderConfigTypes as v,resolveScopeSchema as y}from"./types.js";export{e as cliFlagLabel,t as cliFlagOf,n as cliShortOf,r as createCliArgsParser,i as flagOf,a as generateCliArgsOptions,o as generateCliOptions,u as generateConfigJsonSchema,f as generateConfigMarkdown,g as generateConfigTypes,s as generateEnv,c as generateEnvDts,l as generateEnvTypes,d as generateJsonSchemaFile,_ as renderAllConfigTypes,p as renderConfigFileMarkdown,m as renderConfigIndex,v as renderConfigTypes,h as renderScopeMarkdown,y as resolveScopeSchema};

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

@@ -0,0 +1,24 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { ConfigScopes } from "../types.js";
+//#region packages/config/src/generators/json.d.ts
+export interface GenerateJsonSchemaOptions {
+  /** Output file path. When omitted, nothing is written. */
+  output?: string;
+  /** The base group hoisted to the top level (default `base`). */
+  baseGroup?: string;
+  /** Document metadata overrides. */
+  id?: string;
+  title?: string;
+  description?: string;
+}
+/**
+ * Build the combined untyped JSON Schema document covering every scope, using
+ * untyped's `resolveSchema` on the definitions lowered from the Zod schemas.
+ */
+export declare function generateConfigJsonSchema(scopes: ConfigScopes, options?: GenerateJsonSchemaOptions): Promise<Record<string, unknown>>;
+/** Generate the JSON Schema document into `output`. Returns the path written. */
+export declare function generateJsonSchemaFile(scopes: ConfigScopes, options: GenerateJsonSchemaOptions & {
+  output: string;
+}): Promise<string>;
+//#endregion

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

@@ -0,0 +1 @@
+import{default as e}from"node:path";import"node:url";import.meta.url;import{flattenBaseSchema as t,zodToUntypedDefinition as n}from"../schema.js";import r from"node:fs";import{resolveSchema as i}from"untyped";async function a(a,o={}){let s={};for(let[e,r]of Object.entries(a))s[e]=t(await i(n(r.zodSchema)),o.baseGroup);let c={$schema:`https://json-schema.org/draft/2020-12/schema`,$id:o.id??`https://example.com/schemas/config.json`,title:o.title??`Configuration`,description:o.description??`Every env-var-backed configuration value across all scopes.`,type:`object`,properties:s,required:Object.keys(a)};return o.output&&(r.mkdirSync(e.dirname(o.output),{recursive:!0}),r.writeFileSync(o.output,`${JSON.stringify(c,null,4)}\n`,`utf-8`)),c}async function o(e,t){return await a(e,t),t.output}export{a as generateConfigJsonSchema,o as generateJsonSchemaFile};

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};