@reliverse/dler 1.2.5 → 1.3.0

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/auto.js

@@ -11,7 +11,12 @@ export const autoPreset = definePreset(() => {
           return;
         }
         const sourceFiles = listRecursively(join(ctx.options.rootDir, "src"));
-        const res = inferEntries(ctx.pkg, sourceFiles, ctx.options.rootDir);
+        const res = inferEntries(
+          ctx.pkg,
+          sourceFiles,
+          ctx.options.isLib,
+          ctx.options.rootDir
+        );
         for (const message of res.warnings) {
           warn(ctx, message);
         }
@@ -38,7 +43,7 @@ const getEntrypointPaths = (path) => {
   const segments = normalize(path).split("/");
   return segments.map((_, index) => segments.slice(index).join("/")).filter(Boolean);
 };
-function inferEntries(pkg, sourceFiles, rootDir) {
+function inferEntries(pkg, sourceFiles, isLib, rootDir) {
   const warnings = [];
   sourceFiles.sort((a, b) => a.split("/").length - b.split("/").length);
   const outputs = extractExportFilenames(pkg.exports);
@@ -97,7 +102,7 @@ function inferEntries(pkg, sourceFiles, rootDir) {
     if (output.type === "cjs") {
       cjs = true;
     }
-    const entry = entries.find((i) => i.input === input) || entries[entries.push({ input }) - 1];
+    const entry = entries.find((i) => i.input === input) || entries[entries.push({ input, isLib }) - 1];
     if (/\.d\.(m|c)?ts$/.test(output.file)) {
       dts = true;
     }

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/build.d.ts

@@ -0,0 +1,5 @@
+import type { UnifiedBuildConfig } from "./types.js";
+export declare function unifiedBuild(isLib: boolean, rootDir: string, inputConfig: UnifiedBuildConfig & {
+    config?: string;
+    showOutLog?: boolean;
+}, outDir: string, transpileStub?: boolean): Promise<void>;

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/build.js

@@ -25,7 +25,7 @@ import {
   withTrailingSlash
 } from "./utils.js";
 import { validateDependencies, validatePackage } from "./validate.js";
-export async function build(rootDir, inputConfig, outDir, transpileStub = false) {
+export async function unifiedBuild(isLib, rootDir, inputConfig, outDir, transpileStub = false) {
   const resolvedRootDir = resolve(process.cwd(), rootDir || ".");
   const jiti = createJiti(resolvedRootDir);
   const _buildConfig = await jiti.import(inputConfig?.config || ".config/dler.ts", {
@@ -53,11 +53,12 @@ export async function build(rootDir, inputConfig, outDir, transpileStub = false)
       _transpileStubMode,
       _transpileWatchMode,
       outDir,
-      inputConfig.showOutLog || true
+      inputConfig.showOutLog || true,
+      isLib
     );
   }
 }
-async function _build(rootDir, inputConfig, buildConfig, pkg, cleanedDirs, _transpileStubMode, _transpileWatchMode, outDir, showOutLog) {
+async function _build(rootDir, inputConfig, buildConfig, pkg, cleanedDirs, _transpileStubMode, _transpileWatchMode, outDir, showOutLog, isLib) {
   const timer = createPerfTimer();
   const preset = await resolvePreset(
     buildConfig.preset || pkg.dler?.preset || pkg.build?.preset || inputConfig.preset || "auto",
@@ -143,7 +144,8 @@ async function _build(rootDir, inputConfig, buildConfig, pkg, cleanedDirs, _tran
       transpileWatchOptions: _transpileWatchMode ? {
         exclude: "node_modules/**",
         include: "src/**"
-      } : void 0
+      } : void 0,
+      isLib
     }
   );
   options.outDir = resolve(options.rootDir, options.outDir);
@@ -155,7 +157,8 @@ async function _build(rootDir, inputConfig, buildConfig, pkg, cleanedDirs, _tran
     options,
     pkg,
     usedImports: /* @__PURE__ */ new Set(),
-    warnings: /* @__PURE__ */ new Set()
+    warnings: /* @__PURE__ */ new Set(),
+    isLib
   };
   if (preset.hooks) {
     ctx.hooks.addHooks(preset.hooks);
@@ -168,7 +171,7 @@ async function _build(rootDir, inputConfig, buildConfig, pkg, cleanedDirs, _tran
   }
   await ctx.hooks.callHook("build:prepare", ctx);
   options.entries = options.entries.map(
-    (entry) => typeof entry === "string" ? { input: entry } : entry
+    (entry) => typeof entry === "string" ? { input: entry, isLib } : entry
   );
   for (const entry of options.entries) {
     if (typeof entry.name !== "string") {
@@ -189,6 +192,7 @@ async function _build(rootDir, inputConfig, buildConfig, pkg, cleanedDirs, _tran
     }
     entry.input = resolve(options.rootDir, entry.input);
     entry.outDir = resolve(options.rootDir, entry.outDir || options.outDir);
+    entry.isLib = isLib;
   }
   options.dependencies = Object.keys(pkg.dependencies || {});
   options.peerDependencies = Object.keys(pkg.peerDependencies || {});
@@ -253,7 +257,8 @@ ${options.entries.map((entry) => `  ${dumpObject(entry)}`).join("\n  ")}
     if (!entry) {
       entry = {
         chunk: true,
-        path: file
+        path: file,
+        isLib: ctx.options.isLib
       };
       ctx.buildEntries.push(entry);
     }

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/copy/copy.d.ts

@@ -0,0 +1,2 @@
+import type { BuildContext } from "../types.js";
+export declare function copyBuild(ctx: BuildContext): Promise<void>;

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/copy/copy.js

@@ -48,7 +48,8 @@ export async function copyBuild(ctx) {
             p.value
           )
         ),
-        path: distDir
+        path: distDir,
+        isLib: entry.isLib
       });
     }
   }

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/copy/types.d.ts

@@ -0,0 +1,9 @@
+import type { BaseBuildEntry, BuildContext } from "../types.js";
+export type CopyBuildEntry = BaseBuildEntry & {
+    builder: "copy";
+    pattern?: string | string[];
+};
+export type CopyHooks = {
+    "copy:done": (ctx: BuildContext) => Promise<void> | void;
+    "copy:entries": (ctx: BuildContext, entries: CopyBuildEntry[]) => Promise<void> | void;
+};

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/mkdist/mkdist.d.ts

@@ -0,0 +1,2 @@
+import type { BuildContext } from "../types.js";
+export declare function mkdistBuild(ctx: BuildContext): Promise<void>;

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/mkdist/mkdist.js

@@ -1,8 +1,7 @@
 import { relinka } from "@reliverse/relinka";
 import { mkdist } from "mkdist";
-import { relative } from "pathe";
+import { relative, dirname as pathDirname } from "pathe";
 import {
-  ensuredir,
   rmdir,
   symlink,
   warn
@@ -14,18 +13,34 @@ export async function mkdistBuild(ctx) {
   await ctx.hooks.callHook("mkdist:entries", ctx, entries);
   for (const entry of entries) {
     const distDir = entry.outDir || entry.input;
-    await ensuredir(distDir);
     if (ctx.options.transpileStub) {
       await rmdir(distDir);
       await symlink(entry.input, distDir);
     } else {
+      let srcDir;
+      if (typeof entry.input === "string" && !entry.input.endsWith("/")) {
+        srcDir = ctx.options.isLib ? pathDirname(entry.input) : entry.input;
+        relinka(
+          "verbose",
+          `[mkdist] Using directory from file path: ${srcDir} (from: ${entry.input})`
+        );
+      } else {
+        srcDir = entry.input;
+        relinka("verbose", `[mkdist] Using directory directly: ${srcDir}`);
+      }
       const mkdistOptions = {
-        cleanDist: true,
+        cleanDist: false,
         distDir,
         rootDir: ctx.options.rootDir,
-        srcDir: entry.input,
+        srcDir,
+        format: "esm",
+        ext: entry.ext || "js",
         ...entry
       };
+      relinka(
+        "verbose",
+        `[mkdist] Building with options: srcDir=${mkdistOptions.srcDir}, distDir=${mkdistOptions.distDir}, rootDir=${mkdistOptions.rootDir}`
+      );
       await ctx.hooks.callHook(
         "mkdist:entry:options",
         ctx,
@@ -35,7 +50,8 @@ export async function mkdistBuild(ctx) {
       const output = await mkdist(mkdistOptions);
       ctx.buildEntries.push({
         chunks: output.writtenFiles.map((p) => relative(ctx.options.outDir, p)),
-        path: distDir
+        path: distDir,
+        isLib: ctx.options.isLib
       });
       await ctx.hooks.callHook("mkdist:entry:build", ctx, entry, output);
       if (output.errors) {

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/mkdist/types.d.ts

@@ -0,0 +1,15 @@
+import type { MkdistOptions } from "mkdist";
+import type { BaseBuildEntry, BuildContext } from "../types.js";
+export type MkdistBuildEntry = _BaseAndMkdist & {
+    builder: "mkdist";
+};
+export type MkdistHooks = {
+    "mkdist:done": (ctx: BuildContext) => Promise<void> | void;
+    "mkdist:entries": (ctx: BuildContext, entries: MkdistBuildEntry[]) => Promise<void> | void;
+    "mkdist:entry:build": (ctx: BuildContext, entry: MkdistBuildEntry, output: {
+        writtenFiles: string[];
+    }) => Promise<void> | void;
+    "mkdist:entry:options": (ctx: BuildContext, entry: MkdistBuildEntry, options: MkdistOptions) => Promise<void> | void;
+};
+type _BaseAndMkdist = BaseBuildEntry & MkdistOptions;
+export {};

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/rollup/build.d.ts

@@ -0,0 +1,2 @@
+import type { BuildContext } from "../types.js";
+export declare function rollupBuild(ctx: BuildContext): Promise<void>;

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/rollup/build.js

@@ -43,7 +43,8 @@ export async function rollupBuild(ctx) {
             bytes: mod.renderedLength,
             id
           })),
-          path: entry.fileName
+          path: entry.fileName,
+          isLib: ctx.options.isLib
         });
       }
     }

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/rollup/config.d.ts

@@ -0,0 +1,2 @@
+import type { BuildContext, RollupOptions } from "../types.js";
+export declare function getRollupOptions(ctx: BuildContext): RollupOptions;

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/rollup/plugins/cjs.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "rollup";
+import type { BuildContext } from "../../types.js";
+export declare function cjsPlugin(): Plugin;
+export declare function fixCJSExportTypePlugin(ctx: BuildContext): Plugin;

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/rollup/plugins/esbuild.d.ts

@@ -0,0 +1,13 @@
+import type { FilterPattern } from "@rollup/pluginutils";
+import type { CommonOptions, Loader } from "esbuild";
+import type { Plugin } from "rollup";
+export type EsbuildOptions = CommonOptions & {
+    exclude?: FilterPattern;
+    include?: FilterPattern;
+    /**
+     * Map extension to transpileEsbuild loader
+     * Note that each entry (the extension) needs to start with a dot
+     */
+    loaders?: Record<string, false | Loader>;
+};
+export declare function esbuild(options: EsbuildOptions): Plugin;

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/rollup/plugins/json.d.ts

@@ -0,0 +1,3 @@
+import type { RollupJsonOptions } from "@rollup/plugin-json";
+import type { Plugin } from "rollup";
+export declare function JSONPlugin(options: RollupJsonOptions): Plugin;

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/rollup/plugins/raw.d.ts

@@ -0,0 +1,8 @@
+import type { FilterPattern } from "@rollup/pluginutils";
+import type { Plugin } from "rollup";
+type RawLoaderOptions = {
+    exclude?: FilterPattern;
+    include?: FilterPattern;
+};
+export declare function rawPlugin(opts?: RawLoaderOptions): Plugin;
+export {};

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/rollup/plugins/shebang.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from "rollup";
+export declare function getShebang(code: string, append?: string): string;
+export declare function makeExecutable(filePath: string): Promise<void>;
+export declare function removeShebangPlugin(): Plugin;
+export declare function shebangPlugin(): Plugin;

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/rollup/stub.d.ts

@@ -0,0 +1,2 @@
+import type { BuildContext } from "../types.js";
+export declare function rollupStub(ctx: BuildContext): Promise<void>;

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/rollup/types.d.ts

@@ -0,0 +1,95 @@
+import type { RollupAliasOptions } from "@rollup/plugin-alias";
+import type { RollupCommonJSOptions } from "@rollup/plugin-commonjs";
+import type { RollupJsonOptions } from "@rollup/plugin-json";
+import type { RollupNodeResolveOptions } from "@rollup/plugin-node-resolve";
+import type { RollupReplaceOptions } from "@rollup/plugin-replace";
+import type { RollupOptions as _RollupOptions, OutputOptions, Plugin, RollupBuild } from "rollup";
+import type { Options as RollupDtsOptions } from "rollup-plugin-dts";
+import type { BaseBuildEntry, BuildContext } from "../types.js";
+import type { EsbuildOptions } from "./plugins/esbuild.js";
+export type RollupBuildEntry = BaseBuildEntry & {
+    builder: "rollup";
+};
+export type RollupBuildOptions = {
+    /**
+     * Alias plugin options
+     * Set to `false` to disable the plugin.
+     * Read more: [@rollup/plugin-alias](https://npmjs.com/package/@rollup/plugin-alias)
+     */
+    alias: false | RollupAliasOptions;
+    /**
+     * If enabled, dler generates CommonJS polyfills for ESM builds.
+     */
+    cjsBridge?: boolean;
+    /**
+     * CommonJS plugin options
+     * Set to `false` to disable the plugin.
+     * Read more: [@rollup/plugin-commonjs](https://npmjs.com/package/@rollup/plugin-commonjs)
+     */
+    commonjs: false | RollupCommonJSOptions;
+    /**
+     * DTS plugin options
+     * Set to `false` to disable the plugin.
+     * Read more: [rollup-plugin-dts](https://npmjs.com/package/rollup-plugin-dts)
+     */
+    dts: RollupDtsOptions;
+    /**
+     * If enabled, dler generates a CommonJS build in addition to the ESM build.
+     */
+    emitCJS?: boolean;
+    /**
+     * ESBuild plugin options
+     * Set to `false` to disable the plugin.
+     * Read more: [transpileEsbuild](https://npmjs.com/package/transpileEsbuild)
+     */
+    esbuild: EsbuildOptions | false;
+    /**
+     * Whether to inline dependencies not explicitly set in "dependencies" or "peerDependencies" or as marked externals to the bundle.
+     *
+     * If set to true, all such dependencies will be inlined.
+     * If an array of string or regular expressions is passed, these will be used to determine whether to inline such a dependency.
+     */
+    inlineDependencies?: (RegExp | string)[] | boolean;
+    /**
+     * JSON plugin options
+     * Set to `false` to disable the plugin.
+     * Read more: [@rollup/plugin-json](https://npmjs.com/package/@rollup/plugin-json)
+     */
+    json: false | RollupJsonOptions;
+    /**
+     * Rollup [Output Options](https://rollupjs.org/configuration-options)
+     */
+    output?: OutputOptions;
+    /**
+     * Preserve dynamic imports as-is
+     */
+    preserveDynamicImports?: boolean;
+    /**
+     * Replace plugin options
+     * Set to `false` to disable the plugin.
+     * Read more: [@rollup/plugin-replace](https://npmjs.com/package/@rollup/plugin-replace)
+     */
+    replace: false | RollupReplaceOptions;
+    /**
+     * Resolve plugin options
+     * Set to `false` to disable the plugin.
+     * Read more: [@rollup/plugin-node-resolve](https://npmjs.com/package/@rollup/plugin-node-resolve)
+     */
+    resolve: false | RollupNodeResolveOptions;
+    /**
+     * Enable experimental active watcher
+     *
+     * @experimental
+     */
+    watch?: boolean;
+};
+export type RollupHooks = {
+    "rollup:build": (ctx: BuildContext, build: RollupBuild) => Promise<void> | void;
+    "rollup:done": (ctx: BuildContext) => Promise<void> | void;
+    "rollup:dts:build": (ctx: BuildContext, build: RollupBuild) => Promise<void> | void;
+    "rollup:dts:options": (ctx: BuildContext, options: RollupOptions) => Promise<void> | void;
+    "rollup:options": (ctx: BuildContext, options: RollupOptions) => Promise<void> | void;
+};
+export type RollupOptions = _RollupOptions & {
+    plugins: Plugin[];
+};

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/rollup/utils.d.ts

@@ -0,0 +1,5 @@
+import type { PreRenderedChunk } from "rollup";
+import type { BuildContext } from "../types.js";
+export declare const DEFAULT_EXTENSIONS: string[];
+export declare function getChunkFilename(ctx: BuildContext, chunk: PreRenderedChunk, ext: string): string;
+export declare function resolveAliases(ctx: BuildContext): Record<string, string>;

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/rollup/watch.d.ts

@@ -0,0 +1,2 @@
+import type { RollupOptions } from "../types.js";
+export declare function rollupWatch(rollupOptions: RollupOptions): void;

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/types.d.ts

@@ -0,0 +1,176 @@
+import type { Hookable } from "hookable";
+import type { Jiti, JitiOptions } from "jiti";
+import type { PackageJson } from "pkg-types";
+import type { WatcherOptions } from "rollup";
+import type { CopyBuildEntry, CopyHooks } from "./copy/types.js";
+import type { MkdistBuildEntry, MkdistHooks } from "./mkdist/types.js";
+import type { RollupBuildEntry, RollupBuildOptions, RollupHooks } from "./rollup/types.js";
+import type { UntypedBuildEntry, UntypedHooks } from "./untyped/types.js";
+export type BaseBuildEntry = {
+    builder?: "copy" | "mkdist" | "rollup" | "untyped";
+    declaration?: "compatible" | "node16" | boolean;
+    input: string;
+    name?: string;
+    outDir?: string;
+    isLib: boolean;
+};
+export type { CopyBuildEntry } from "./copy/types.js";
+export type { MkdistBuildEntry } from "./mkdist/types.js";
+/** Bundler types */
+export type { RollupBuildEntry, RollupBuildOptions, RollupOptions, } from "./rollup/types.js";
+export type { UntypedBuildEntry, UntypedOutput, UntypedOutputs, } from "./untyped/types.js";
+export type BuildContext = {
+    buildEntries: {
+        bytes?: number;
+        chunk?: boolean;
+        chunks?: string[];
+        exports?: string[];
+        modules?: {
+            bytes: number;
+            id: string;
+        }[];
+        path: string;
+        isLib: boolean;
+    }[];
+    hooks: Hookable<BuildHooks>;
+    jiti: Jiti;
+    options: BuildOptions;
+    pkg: PackageJson;
+    usedImports: Set<string>;
+    warnings: Set<string>;
+    isLib: boolean;
+};
+export type BuildEntry = BaseBuildEntry | CopyBuildEntry | MkdistBuildEntry | RollupBuildEntry | UntypedBuildEntry;
+export type BuildHooks = CopyHooks & MkdistHooks & RollupHooks & UntypedHooks & {
+    "build:before": (ctx: BuildContext) => Promise<void> | void;
+    "build:done": (ctx: BuildContext) => Promise<void> | void;
+    "build:prepare": (ctx: BuildContext) => Promise<void> | void;
+};
+export type BuildOptions = {
+    /**
+     * Create aliases for module imports to reference modules in code using more concise paths.
+     * Allow you to specify an alias for the module path.
+     */
+    alias: Record<string, string>;
+    /**
+     * Clean the output directory before building.
+     */
+    clean: boolean;
+    /**
+     * Whether to generate declaration files.
+     * * `compatible` means "src/index.ts" will generate "dist/index.d.mts", "dist/index.d.cts" and "dist/index.d.ts".
+     * * `node16` means "src/index.ts" will generate "dist/index.d.mts" and "dist/index.d.cts".
+     * * `true` is equivalent to `compatible`.
+     * * `false` will disable declaration generation.
+     * * `undefined` will auto detect based on "package.json". If "package.json" has "types" field, it will be `"compatible"`, otherwise `false`.
+     */
+    declaration?: "compatible" | "node16" | boolean;
+    dependencies: string[];
+    devDependencies: string[];
+    /**
+     * Build entries.
+     */
+    entries: BuildEntry[];
+    /**
+     * Used to specify which modules or libraries should be considered
+     * external dependencies and not included in the final build product.
+     */
+    externals: (RegExp | string)[];
+    /**
+     * Terminate the build process when a warning appears
+     */
+    failOnWarn?: boolean;
+    /**
+     * Whether the current build is for a library.
+     */
+    isLib: boolean;
+    /**
+     * The name of the project.
+     */
+    name: string;
+    /**
+     * Output directory.
+     */
+    outDir: string;
+    /**
+     * Run different types of builds (untyped, mkdist, Rollup, copy) simultaneously.
+     */
+    parallel: boolean;
+    peerDependencies: string[];
+    /**
+     * Replace the text in the source code with rules.
+     */
+    replace: Record<string, string>;
+    /**
+     * [Rollup](https://rollupjs.org/configuration-options) Build Options
+     */
+    rollup: RollupBuildOptions;
+    /**
+     * The root directory of the project.
+     */
+    rootDir: string;
+    /**
+     * Hide output logs during the build process.
+     * When true, suppresses non-essential console output.
+     */
+    showOutLog?: boolean;
+    /**
+     * @experimental
+     * Generate source mapping file.
+     */
+    transpileSourcemap: boolean;
+    /**
+     * Whether to build with JIT transpileStubs.
+     * Read more: [transpileStubbing](https://antfu.me/posts/publish-esm-and-cjs#transpileStubbing)
+     */
+    transpileStub: boolean;
+    /**
+     * Stub options, where [jiti](https://github.com/unjs/jiti)
+     * is an object of type `Omit<JitiOptions, "transform" | "onError">`.
+     */
+    transpileStubOptions: {
+        jiti: Omit<JitiOptions, "onError" | "transform">;
+    };
+    /**
+     * Whether to build and actively transpileWatch the file changes.
+     *
+     * @experimental This feature is experimental and incomplete.
+     */
+    transpileWatch: boolean;
+    /**
+     * Watch mode options.
+     */
+    transpileWatchOptions: undefined | WatcherOptions;
+};
+export type BuildPreset = (() => UnifiedBuildConfig) | UnifiedBuildConfig;
+/**
+ * In addition to basic `entries`, `presets`, and `hooks`,
+ * there are also all the properties of `BuildOptions` except for BuildOptions's `entries`.
+ */
+export type UnifiedBuildConfig = DeepPartial<Omit<BuildOptions, "entries">> & {
+    /**
+     * Specify the entry file or entry module during the construction process.
+     */
+    entries?: (BuildEntry | string)[];
+    /**
+     * Used to define hook functions during the construction process to perform custom operations during specific construction stages.
+     * This configuration allows you to insert custom logic during the build process to meet specific requirements or perform additional operations.
+     */
+    hooks?: Partial<BuildHooks>;
+    /**
+     * Used to specify the preset build configuration.
+     */
+    preset?: BuildPreset | string;
+    /**
+     * Used to create a stub for the build configuration.
+     * A stub is a simplified version of a mock object that is used to simulate the behavior of a real object.
+     * It is used to test the behavior of the object under test.
+     * @see https://turing.com/kb/stub-vs-mock#what-exactly-is-a-stub?
+     */
+    stub?: boolean;
+};
+type DeepPartial<T> = {
+    [P in keyof T]?: DeepPartial<T[P]>;
+};
+export declare function defineBuildConfig(config: UnifiedBuildConfig | UnifiedBuildConfig[]): UnifiedBuildConfig[];
+export declare function definePreset(preset: BuildPreset): BuildPreset;

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/untyped/index.d.ts

@@ -0,0 +1,2 @@
+import type { BuildContext } from "../types.js";
+export declare function typesBuild(ctx: BuildContext): Promise<void>;

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/untyped/index.js

@@ -69,8 +69,8 @@ export async function typesBuild(ctx) {
         declaration: entry.declaration ? {
           contents: generateTypes(schema, {
             interfaceName: pascalCase(`${entry.name}-schema`)
-            // addDefaults: true, // TODO: Add JSDoc default values (allow to configure via .config/dler.ts)
-            // addDescription: true, // TODO: Add JSDoc descriptions (allow to configure via .config/dler.ts)
+            // addDefaults: true, // TODO: Add JSDoc default values (allow to configure via dler.config.ts)
+            // addDescription: true, // TODO: Add JSDoc descriptions (allow to configure via dler.config.ts)
           }),
           fileName: `${entry.name}.d.ts`
         } : void 0,

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/untyped/types.d.ts

@@ -0,0 +1,23 @@
+import type { Schema } from "untyped";
+import type { BaseBuildEntry, BuildContext } from "../types.js";
+export type UntypedBuildEntry = BaseBuildEntry & {
+    builder: "untyped";
+    defaults?: Record<string, any>;
+};
+export type UntypedHooks = {
+    "untyped:done": (ctx: BuildContext) => Promise<void> | void;
+    "untyped:entries": (ctx: BuildContext, entries: UntypedBuildEntry[]) => Promise<void> | void;
+    "untyped:entry:options": (ctx: BuildContext, entry: UntypedBuildEntry, options: any) => Promise<void> | void;
+    "untyped:entry:outputs": (ctx: BuildContext, entry: UntypedBuildEntry, outputs: UntypedOutputs) => Promise<void> | void;
+    "untyped:entry:schema": (ctx: BuildContext, entry: UntypedBuildEntry, schema: Schema) => Promise<void> | void;
+};
+export type UntypedOutput = {
+    contents: string;
+    fileName: string;
+};
+export type UntypedOutputs = {
+    declaration?: UntypedOutput;
+    defaults: UntypedOutput;
+    markdown: UntypedOutput;
+    schema: UntypedOutput;
+};

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/utils.d.ts

@@ -0,0 +1,20 @@
+import type { PackageJson } from "pkg-types";
+import type { BuildContext, BuildPreset, UnifiedBuildConfig } from "./types.js";
+type OutputDescriptor = {
+    file: string;
+    type?: "cjs" | "esm";
+};
+export declare function arrayIncludes(arr: (RegExp | string)[], searchElement: string): boolean;
+export declare function dumpObject(obj: Record<string, any>): string;
+export declare function ensuredir(path: string): Promise<void>;
+export declare function extractExportFilenames(exports: PackageJson["exports"], conditions?: string[]): OutputDescriptor[];
+export declare function getpkg(id?: string): string;
+export declare function inferPkgExternals(pkg: PackageJson): (RegExp | string)[];
+export declare function listRecursively(path: string): string[];
+export declare function removeExtension(filename: string): string;
+export declare function resolvePreset(preset: BuildPreset | string, rootDir: string): Promise<UnifiedBuildConfig>;
+export declare function rmdir(dir: string): Promise<void>;
+export declare function symlink(from: string, to: string, force?: boolean): Promise<void>;
+export declare function warn(ctx: BuildContext, message: string): void;
+export declare function withTrailingSlash(path: string): string;
+export {};

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/validate.d.ts

@@ -0,0 +1,4 @@
+import type { PackageJson } from "pkg-types";
+import type { BuildContext } from "./types.js";
+export declare function validateDependencies(ctx: BuildContext): void;
+export declare function validatePackage(pkg: PackageJson, rootDir: string, ctx: BuildContext): void;

package/bin/libs/sdk/sdk-impl/library-flow.d.ts

@@ -0,0 +1,11 @@
+import type { BundlerName, Esbuild, ExcludeMode, LibConfig, NpmOutExt, Sourcemap, transpileFormat, transpileTarget } from "../sdk-types.js";
+import type { PerfTimer } from "./utils/utils-perf.js";
+/**
+ * Processes libraries based on build mode.
+ */
+export declare function processLibraryFlow(timer: PerfTimer, isDev: boolean, libsActMode: string, libsList: Record<string, LibConfig>, distJsrDryRun: boolean, distJsrFailOnWarn: boolean, libsDirDist: string, libsDirSrc: string, commonPubPause: boolean, commonPubRegistry: string, unifiedBundlerOutExt: NpmOutExt, distNpmBuilder: BundlerName, coreEntrySrcDir: string, rmDepsMode: ExcludeMode, rmDepsPatterns: string[], transpileEsbuild: Esbuild, transpileTarget: transpileTarget, transpileFormat: transpileFormat, transpileSplitting: boolean, transpileSourcemap: Sourcemap, transpilePublicPath: string, distJsrBuilder: BundlerName, transpileStub: boolean, transpileWatch: boolean, distJsrOutFilesExt: NpmOutExt): Promise<void>;
+/**
+ * Processes all libs defined in config.libsList.
+ * Builds and optionally publishes each library based on configuration.
+ */
+export declare function libraries_buildPublish(isDev: boolean, timer: PerfTimer, libsList: Record<string, LibConfig>, distJsrDryRun: boolean, distJsrFailOnWarn: boolean, libsDirDist: string, libsDirSrc: string, commonPubPause: boolean, commonPubRegistry: string, unifiedBundlerOutExt: NpmOutExt, distNpmBuilder: BundlerName, coreEntrySrcDir: string, rmDepsMode: ExcludeMode, rmDepsPatterns: string[], transpileEsbuild: Esbuild, transpileTarget: transpileTarget, transpileFormat: transpileFormat, transpileSplitting: boolean, transpileSourcemap: Sourcemap, transpilePublicPath: string, distJsrBuilder: BundlerName, transpileStub: boolean, transpileWatch: boolean, distJsrOutFilesExt: NpmOutExt): Promise<void>;