@reliverse/dler 1.7.16 → 1.7.17

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

@@ -10,6 +10,7 @@ import prettyMilliseconds from "pretty-ms";
 import { glob } from "tinyglobby";
 import { createPerfTimer, getElapsedPerfTime } from "../../../utils/utils-perf.js";
 import { copyBuild } from "./copy/copy-mod.js";
+import { useSpinner } from "./mkdist/mkdist-impl/utils/spinner.js";
 import { mkdistBuild } from "./mkdist/mkdist-mod.js";
 import { rollupBuild } from "./rollup/build.js";
 import { typesBuild } from "./untyped/untyped-mod.js";
@@ -72,259 +73,305 @@ export async function unifiedBuild(inputSourceDir, coreIsCLI, isLib, rootDir, in
   }
 }
 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",
-    rootDir
-  );
-  const options = defu(buildConfig, pkg.dler || pkg.build, inputConfig, preset, {
-    alias: {},
-    clean: false,
-    declaration: void 0,
-    dependencies: [],
-    devDependencies: [],
-    entries: [],
-    externals: [...Module.builtinModules, ...Module.builtinModules.map((m) => `node:${m}`)],
-    transpileFailOnWarn: true,
-    name: (pkg?.name || "").split("/").pop() || "default",
-    outDir,
-    parallel: false,
-    peerDependencies: [],
-    replace: {},
-    rollup: {
-      alias: {},
-      cjsBridge: false,
-      commonjs: {
-        ignoreTryCatch: true
-      },
-      dts: {
-        compilerOptions: {
-          /**
-           * @see https://github.com/Swatinem/rollup-plugin-dts/issues/127
-           */
-          composite: false,
+  await useSpinner.withTiming(
+    async (buildSpinner) => {
+      const timer = createPerfTimer();
+      buildSpinner.setText("Resolving build configuration...");
+      const preset = await resolvePreset(
+        buildConfig.preset || pkg.dler?.preset || pkg.build?.preset || inputConfig.preset || "auto",
+        rootDir
+      );
+      const options = defu(buildConfig, pkg.dler || pkg.build, inputConfig, preset, {
+        alias: {},
+        clean: false,
+        declaration: void 0,
+        dependencies: [],
+        devDependencies: [],
+        entries: [],
+        externals: [...Module.builtinModules, ...Module.builtinModules.map((m) => `node:${m}`)],
+        transpileFailOnWarn: true,
+        name: (pkg?.name || "").split("/").pop() || "default",
+        outDir,
+        parallel: false,
+        peerDependencies: [],
+        replace: {},
+        rollup: {
+          alias: {},
+          cjsBridge: false,
+          commonjs: {
+            ignoreTryCatch: true
+          },
+          dts: {
+            compilerOptions: {
+              /**
+               * @see https://github.com/Swatinem/rollup-plugin-dts/issues/127
+               */
+              composite: false,
+              /**
+               * @see https://github.com/Swatinem/rollup-plugin-dts/issues/143
+               */
+              preserveSymlinks: false
+            },
+            respectExternal: true
+          },
+          emitCJS: false,
+          esbuild: { target: "esnext" },
+          inlineDependencies: false,
+          json: {
+            preferConst: true
+          },
+          output: {
+            /**
+             * @see https://v8.dev/features/import-attributes
+             */
+            importAttributesKey: "with"
+          },
+          preserveDynamicImports: true,
+          // Plugins
+          replace: {
+            preventAssignment: true
+          },
+          resolve: {
+            preferBuiltins: true
+          },
+          watch: false
+        },
+        rootDir,
+        showOutLog: true,
+        transpileSourcemap: false,
+        transpileStub: _transpileStubMode,
+        transpileStubOptions: {
           /**
-           * @see https://github.com/Swatinem/rollup-plugin-dts/issues/143
+           * @see https://github.com/unjs/jiti#%EF%B8%8F-options
            */
-          preserveSymlinks: false
+          jiti: {
+            alias: {},
+            interopDefault: true
+          }
         },
-        respectExternal: true
-      },
-      emitCJS: false,
-      esbuild: { target: "esnext" },
-      inlineDependencies: false,
-      json: {
-        preferConst: true
-      },
-      output: {
-        /**
-         * @see https://v8.dev/features/import-attributes
-         */
-        importAttributesKey: "with"
-      },
-      preserveDynamicImports: true,
-      // Plugins
-      replace: {
-        preventAssignment: true
-      },
-      resolve: {
-        preferBuiltins: true
-      },
-      watch: false
-    },
-    rootDir,
-    showOutLog: true,
-    transpileSourcemap: false,
-    transpileStub: _transpileStubMode,
-    transpileStubOptions: {
-      /**
-       * @see https://github.com/unjs/jiti#%EF%B8%8F-options
-       */
-      jiti: {
-        alias: {},
-        interopDefault: true
+        transpileWatch: _transpileWatchMode,
+        transpileWatchOptions: _transpileWatchMode ? {
+          exclude: "node_modules/**",
+          include: "src/**"
+        } : void 0,
+        isLib
+      });
+      shouldStopAtStep(5);
+      relinka("log", "Build-specific configuration merged with defaults");
+      relinka("verbose", `Build options: clean=${options.clean}, parallel=${options.parallel}`);
+      relinka("verbose", `Declaration files: ${options.declaration ? "enabled" : "disabled"}`);
+      options.outDir = resolve(options.rootDir, options.outDir);
+      const jiti = createJiti(options.rootDir, { interopDefault: true });
+      buildSpinner.setText("Initializing build context...");
+      const ctx = {
+        buildEntries: [],
+        hooks: createHooks(),
+        jiti,
+        options,
+        pkg,
+        usedImports: /* @__PURE__ */ new Set(),
+        warnings: /* @__PURE__ */ new Set(),
+        isLib
+      };
+      if (preset.hooks) {
+        ctx.hooks.addHooks(preset.hooks);
       }
-    },
-    transpileWatch: _transpileWatchMode,
-    transpileWatchOptions: _transpileWatchMode ? {
-      exclude: "node_modules/**",
-      include: "src/**"
-    } : void 0,
-    isLib
-  });
-  shouldStopAtStep(5);
-  relinka("log", "Build-specific configuration merged with defaults");
-  relinka("verbose", `Build options: clean=${options.clean}, parallel=${options.parallel}`);
-  relinka("verbose", `Declaration files: ${options.declaration ? "enabled" : "disabled"}`);
-  options.outDir = resolve(options.rootDir, options.outDir);
-  const jiti = createJiti(options.rootDir, { interopDefault: true });
-  const ctx = {
-    buildEntries: [],
-    hooks: createHooks(),
-    jiti,
-    options,
-    pkg,
-    usedImports: /* @__PURE__ */ new Set(),
-    warnings: /* @__PURE__ */ new Set(),
-    isLib
-  };
-  if (preset.hooks) {
-    ctx.hooks.addHooks(preset.hooks);
-  }
-  if (inputConfig.hooks) {
-    ctx.hooks.addHooks(inputConfig.hooks);
-  }
-  if (buildConfig.hooks) {
-    ctx.hooks.addHooks(buildConfig.hooks);
-  }
-  await ctx.hooks.callHook("build:prepare", ctx);
-  options.entries = options.entries.map(
-    (entry) => typeof entry === "string" ? { input: entry, isLib } : entry
-  );
-  for (const entry of options.entries) {
-    if (typeof entry.name !== "string") {
-      let relativeInput = isAbsolute(entry.input) ? relative(rootDir, entry.input) : normalize(entry.input);
-      if (relativeInput.startsWith("./")) {
-        relativeInput = relativeInput.slice(2);
+      if (inputConfig.hooks) {
+        ctx.hooks.addHooks(inputConfig.hooks);
       }
-      entry.name = removeExtension(relativeInput.replace(/^src\//, ""));
-    }
-    if (!entry.input) {
-      throw new Error(`Missing entry input: ${dumpObject(entry)}`);
-    }
-    if (!entry.builder) {
-      entry.builder = entry.input.endsWith("/") ? "mkdist" : "rollup";
-    }
-    if (options.declaration !== void 0 && entry.declaration === void 0) {
-      entry.declaration = options.declaration;
-    }
-    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 || {});
-  options.devDependencies = Object.keys(pkg.devDependencies || {});
-  options.externals.push(...inferPkgExternals(pkg));
-  options.externals = [...new Set(options.externals)];
-  await ctx.hooks.callHook("build:before", ctx);
-  relinka(
-    "verbose",
-    `${options.transpileStub ? "Stubbing" : "[unified] Building"} ${options.name}`
-  );
-  if (process.env.DEBUG) {
-    relinka(
-      "log",
-      `Root dir: ${options.rootDir}
+      if (buildConfig.hooks) {
+        ctx.hooks.addHooks(buildConfig.hooks);
+      }
+      await ctx.hooks.callHook("build:prepare", ctx);
+      buildSpinner.setText("Processing build entries...");
+      options.entries = options.entries.map(
+        (entry) => typeof entry === "string" ? { input: entry, isLib } : entry
+      );
+      for (const entry of options.entries) {
+        if (typeof entry.name !== "string") {
+          let relativeInput = isAbsolute(entry.input) ? relative(rootDir, entry.input) : normalize(entry.input);
+          if (relativeInput.startsWith("./")) {
+            relativeInput = relativeInput.slice(2);
+          }
+          entry.name = removeExtension(relativeInput.replace(/^src\//, ""));
+        }
+        if (!entry.input) {
+          throw new Error(`Missing entry input: ${dumpObject(entry)}`);
+        }
+        if (!entry.builder) {
+          entry.builder = entry.input.endsWith("/") ? "mkdist" : "rollup";
+        }
+        if (options.declaration !== void 0 && entry.declaration === void 0) {
+          entry.declaration = options.declaration;
+        }
+        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 || {});
+      options.devDependencies = Object.keys(pkg.devDependencies || {});
+      options.externals.push(...inferPkgExternals(pkg));
+      options.externals = [...new Set(options.externals)];
+      await ctx.hooks.callHook("build:before", ctx);
+      relinka(
+        "verbose",
+        `${options.transpileStub ? "Stubbing" : "[unified] Building"} ${options.name}`
+      );
+      if (process.env.DEBUG) {
+        relinka(
+          "log",
+          `Root dir: ${options.rootDir}
 Entries:
 ${options.entries.map((entry) => `  ${dumpObject(entry)}`).join("\n  ")}
 `
-    );
-  }
-  if (options.clean) {
-    for (const dir of new Set(
-      options.entries.map((e) => e.outDir).filter((p) => !!p).sort()
-    )) {
-      if (dir === options.rootDir || options.rootDir.startsWith(withTrailingSlash(dir)) || cleanedDirs.some((c) => dir.startsWith(c))) {
-        continue;
+        );
       }
-      cleanedDirs.push(dir);
-      relinka("log", `Cleaning dist directory: \`./${relative(process.cwd(), dir)}\``);
-      await rmdir(dir);
-      await fsp.mkdir(dir, { recursive: true });
-    }
-  }
-  const buildTasks = [
-    typesBuild,
-    // untyped
-    mkdistBuild,
-    // mkdist
-    rollupBuild,
-    // rollup
-    copyBuild
-    // copy
-  ];
-  if (options.parallel) {
-    await Promise.all(buildTasks.map((task) => task(ctx)));
-  } else {
-    for (const task of buildTasks) {
-      await task(ctx);
-    }
-  }
-  if (options.transpileStub || options.transpileWatch) {
-    await ctx.hooks.callHook("build:done", ctx);
-    return;
-  }
-  relinka("success", `Build succeeded for ${options.name}`);
-  const outFiles = await glob(["**"], { cwd: options.outDir });
-  for (const file of outFiles) {
-    let entry = ctx.buildEntries.find((e) => e.path === file);
-    if (!entry) {
-      entry = {
-        chunk: true,
-        path: file,
-        isLib: ctx.options.isLib
-      };
-      ctx.buildEntries.push(entry);
-    }
-    if (!entry.bytes) {
-      const stat = await fsp.stat(resolve(options.outDir, file));
-      entry.bytes = stat.size;
-    }
-  }
-  const rPath = (p) => relative(process.cwd(), resolve(options.outDir, p));
-  if (showOutLog) {
-    for (const entry of ctx.buildEntries.filter((e) => !e.chunk)) {
-      let totalBytes = entry.bytes || 0;
-      for (const chunk of entry.chunks || []) {
-        totalBytes += ctx.buildEntries.find((e) => e.path === chunk)?.bytes || 0;
+      if (options.clean) {
+        buildSpinner.setText("Cleaning output directories...");
+        for (const dir of new Set(
+          options.entries.map((e) => e.outDir).filter((p) => !!p).sort()
+        )) {
+          if (dir === options.rootDir || options.rootDir.startsWith(withTrailingSlash(dir)) || cleanedDirs.some((c) => dir.startsWith(c))) {
+            continue;
+          }
+          cleanedDirs.push(dir);
+          relinka("log", `Cleaning dist directory: \`./${relative(process.cwd(), dir)}\``);
+          await rmdir(dir);
+          await fsp.mkdir(dir, { recursive: true });
+        }
       }
-      let line = `  ${rPath(entry.path)} (${[
-        totalBytes && `total size: ${prettyBytes(totalBytes)}`,
-        entry.bytes && `chunk size: ${prettyBytes(entry.bytes)}`,
-        entry.exports?.length && `exports: ${entry.exports.join(", ")}`
-      ].filter(Boolean).join(", ")})`;
-      if (entry.chunks?.length) {
-        line += `
-${entry.chunks.map((p) => {
-          const chunk = ctx.buildEntries.find((e) => e.path === p) || {};
-          return `  \u2514\u2500 ${rPath(p)}${chunk.bytes ? ` (${prettyBytes(chunk.bytes)})` : ""}`;
-        }).join("\n")}`;
+      const buildTasks = [
+        { name: "Type generation", task: typesBuild },
+        { name: "mkdist build", task: mkdistBuild },
+        { name: "Rollup build", task: rollupBuild },
+        { name: "Copy files", task: copyBuild }
+      ];
+      const activeTasks = buildTasks.filter(({ task }) => {
+        if (task === typesBuild) return options.entries.some((e) => e.builder === "untyped");
+        if (task === mkdistBuild) return options.entries.some((e) => e.builder === "mkdist");
+        if (task === rollupBuild) return options.entries.some((e) => e.builder === "rollup");
+        if (task === copyBuild) return options.entries.some((e) => e.builder === "copy");
+        return false;
+      });
+      if (activeTasks.length === 0) {
+        buildSpinner.setText("No build tasks to execute");
+      } else {
+        let completedTasks = 0;
+        if (options.parallel) {
+          buildSpinner.setText(`Running ${activeTasks.length} build tasks in parallel...`);
+          await Promise.all(
+            activeTasks.map(async ({ task }) => {
+              await task(ctx);
+              completedTasks++;
+              buildSpinner.setProgress({
+                current: completedTasks,
+                total: activeTasks.length
+              });
+            })
+          );
+        } else {
+          for (const { task, name } of activeTasks) {
+            completedTasks++;
+            buildSpinner.setProgress({
+              current: completedTasks,
+              total: activeTasks.length
+            });
+            buildSpinner.setText(`Running ${name}...`);
+            await task(ctx);
+          }
+        }
       }
-      if (entry.modules?.length) {
-        line += `
+      if (options.transpileStub || options.transpileWatch) {
+        await ctx.hooks.callHook("build:done", ctx);
+        return;
+      }
+      buildSpinner.setText("Finalizing build output...");
+      relinka("success", `Build succeeded for ${options.name}`);
+      const outFiles = await glob(["**"], { cwd: options.outDir });
+      for (const file of outFiles) {
+        let entry = ctx.buildEntries.find((e) => e.path === file);
+        if (!entry) {
+          entry = {
+            chunk: true,
+            path: file,
+            isLib: ctx.options.isLib
+          };
+          ctx.buildEntries.push(entry);
+        }
+        if (!entry.bytes) {
+          const stat = await fsp.stat(resolve(options.outDir, file));
+          entry.bytes = stat.size;
+        }
+      }
+      const rPath = (p) => relative(process.cwd(), resolve(options.outDir, p));
+      if (showOutLog) {
+        for (const entry of ctx.buildEntries.filter((e) => !e.chunk)) {
+          let totalBytes = entry.bytes || 0;
+          for (const chunk of entry.chunks || []) {
+            totalBytes += ctx.buildEntries.find((e) => e.path === chunk)?.bytes || 0;
+          }
+          let line = `  ${rPath(entry.path)} (${[
+            totalBytes && `total size: ${prettyBytes(totalBytes)}`,
+            entry.bytes && `chunk size: ${prettyBytes(entry.bytes)}`,
+            entry.exports?.length && `exports: ${entry.exports.join(", ")}`
+          ].filter(Boolean).join(", ")})`;
+          if (entry.chunks?.length) {
+            line += `
+${entry.chunks.map((p) => {
+              const chunk = ctx.buildEntries.find((e) => e.path === p) || {};
+              return `  \u2514\u2500 ${rPath(p)}${chunk.bytes ? ` (${prettyBytes(chunk.bytes)})` : ""}`;
+            }).join("\n")}`;
+          }
+          if (entry.modules?.length) {
+            line += `
 ${entry.modules.filter((m) => m.id.includes("node_modules")).sort((a, b) => (b.bytes || 0) - (a.bytes || 0)).map((m) => {
-          return `  \u{1F4E6} ${rPath(m.id)}${m.bytes ? ` (${prettyBytes(m.bytes)})` : ""}`;
-        }).join("\n")}`;
+              return `  \u{1F4E6} ${rPath(m.id)}${m.bytes ? ` (${prettyBytes(m.bytes)})` : ""}`;
+            }).join("\n")}`;
+          }
+          relinka("log", entry.chunk ? line : line);
+        }
+        const elapsedTime = getElapsedPerfTime(timer);
+        const transpileFormattedTime = prettyMilliseconds(elapsedTime, {
+          verbose: true
+        });
+        const totalSize = ctx.buildEntries.reduce((a, e) => a + (e.bytes || 0), 0);
+        buildSpinner.setText(
+          `Build complete! ${prettyBytes(totalSize)} in ${transpileFormattedTime}`
+        );
+        relinka(
+          "info",
+          `\u03A3 Total dist size: ${prettyBytes(totalSize)} (build time: ${transpileFormattedTime})`
+        );
       }
-      relinka("log", entry.chunk ? line : line);
-    }
-    const elapsedTime = getElapsedPerfTime(timer);
-    const transpileFormattedTime = prettyMilliseconds(elapsedTime, {
-      verbose: true
-    });
-    relinka(
-      "info",
-      `\u03A3 Total dist size: ${prettyBytes(ctx.buildEntries.reduce((a, e) => a + (e.bytes || 0), 0))} (build time: ${transpileFormattedTime})`
-    );
-  }
-  validateDependencies(ctx);
-  validatePackage(pkg, rootDir, ctx);
-  await ctx.hooks.callHook("build:done", ctx);
-  if (ctx.warnings.size > 0) {
-    relinka(
-      "warn",
-      `Build is done with some warnings:
+      validateDependencies(ctx);
+      validatePackage(pkg, rootDir, ctx);
+      await ctx.hooks.callHook("build:done", ctx);
+      if (ctx.warnings.size > 0) {
+        const warningMessage = `Build completed with ${ctx.warnings.size} warnings`;
+        buildSpinner.warn(warningMessage);
+        relinka(
+          "warn",
+          `Build is done with some warnings:
 ${[...ctx.warnings].map((msg) => `- ${msg}`).join("\n")}`
-    );
-    if (ctx.options.transpileFailOnWarn) {
-      relinka(
-        "error",
-        "Exiting with code (1). You can change this behavior by setting `transpileFailOnWarn: false` ."
-      );
-      process.exit(1);
+        );
+        if (ctx.options.transpileFailOnWarn) {
+          relinka(
+            "error",
+            "Exiting with code (1). You can change this behavior by setting `transpileFailOnWarn: false` ."
+          );
+          process.exit(1);
+        }
+        shouldStopAtStep(15);
+        relinka("info", `Build complete (with ${ctx.warnings.size} warnings)`);
+      }
+    },
+    {
+      text: _transpileStubMode ? `Stubbing ${pkg?.name || "project"}...` : `Building ${pkg?.name || "project"}...`,
+      color: "green",
+      successText: `${pkg?.name || "Project"} built successfully!`,
+      failText: `Build failed for ${pkg?.name || "project"}`,
+      prefixText: "[unified]"
     }
-    shouldStopAtStep(15);
-    relinka("info", `Build complete (with ${ctx.warnings.size} warnings)`);
-  }
+  );
 }

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

@@ -1,17 +1,17 @@
 import type { SFCBlock } from "vue/compiler-sfc";
 import type { InputFile, Loader, LoaderContext, OutputFile } from "../../../../../../../sdk-types.js";
-export type DefineVueLoaderOptions = {
+export interface DefineVueLoaderOptions {
     blockLoaders?: Record<string, VueBlockLoader | undefined>;
-};
+}
 export type VueBlock = Pick<SFCBlock, "type" | "content" | "attrs">;
 export type VueBlockLoader = (block: VueBlock, context: LoaderContext & {
     rawInput: InputFile;
     addOutput: (...files: OutputFile[]) => void;
 }) => Promise<VueBlock | undefined>;
-export type DefaultBlockLoaderOptions = {
+export interface DefaultBlockLoaderOptions {
     type: "script" | "style" | "template";
     outputLang: string;
     validExtensions?: string[];
-};
+}
 export declare const fallbackVueLoader: Loader;
 export declare const vueLoader: Loader;

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

@@ -1,8 +1,11 @@
 import type { MkdistOptions } from "../../../../../../sdk-types.js";
 export declare function mkdist(options?: MkdistOptions): Promise<{
-    errors: {
-        filename: string;
-        errors: TypeError[];
-    }[];
-    writtenFiles: string[];
+    result: {
+        errors: {
+            filename: string;
+            errors: TypeError[];
+        }[];
+        writtenFiles: string[];
+    };
+    duration: number;
 }>;