@reliverse/dler 1.7.62 → 1.7.64

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

@@ -1,5 +1,5 @@
 import { resolve, extname, join, basename, dirname } from "@reliverse/pathkit";
-import { useSpinner } from "@reliverse/rempts";
+import { relinka } from "@reliverse/relinka";
 import defu from "defu";
 import fsp from "node:fs/promises";
 import { glob } from "tinyglobby";
@@ -8,206 +8,196 @@ import { getDeclarations, normalizeCompilerOptions } from "./utils/dts.js";
 import { copyFileWithStream } from "./utils/fs.js";
 import { getVueDeclarations } from "./utils/vue-dts.js";
 export async function mkdist(options = {}) {
-  return await useSpinner.withTiming(
-    async (mainSpinner) => {
-      options.rootDir = resolve(process.cwd(), options.rootDir || ".");
-      options.srcDir = resolve(options.rootDir, options.srcDir || "src");
-      options.distDir = resolve(options.rootDir, options.distDir || "dist");
-      if (options.cleanDist !== false) {
-        mainSpinner.setText("Cleaning distribution directory...");
-        await fsp.unlink(options.distDir).catch(() => {
-        });
-        await fsp.rm(options.distDir, { recursive: true, force: true });
-        await fsp.mkdir(options.distDir, { recursive: true });
+  const startTime = Date.now();
+  options.rootDir = resolve(process.cwd(), options.rootDir || ".");
+  options.srcDir = resolve(options.rootDir, options.srcDir || "src");
+  options.distDir = resolve(options.rootDir, options.distDir || "dist");
+  if (options.cleanDist !== false) {
+    relinka("info", "Cleaning distribution directory...");
+    await fsp.unlink(options.distDir).catch(() => {
+    });
+    await fsp.rm(options.distDir, { recursive: true, force: true });
+    await fsp.mkdir(options.distDir, { recursive: true });
+  }
+  relinka("info", "Scanning input files...");
+  const filePaths = await glob(options.pattern || "**", {
+    absolute: false,
+    ignore: ["**/node_modules", "**/coverage", "**/.git"],
+    cwd: options.srcDir,
+    dot: true,
+    ...options.globOptions
+  });
+  const files = filePaths.map((path) => {
+    const sourcePath = resolve(options.srcDir, path);
+    return {
+      path,
+      srcPath: sourcePath,
+      extension: extname(path),
+      getContents: () => fsp.readFile(sourcePath, { encoding: "utf8" })
+    };
+  });
+  relinka("info", `Found ${files.length} files to process`);
+  options.typescript ||= {};
+  if (options.typescript.compilerOptions) {
+    relinka("info", "Normalizing TypeScript compiler options...");
+    options.typescript.compilerOptions = await normalizeCompilerOptions(
+      options.typescript.compilerOptions
+    );
+  }
+  options.typescript.compilerOptions = defu(
+    { noEmit: false },
+    options.typescript.compilerOptions,
+    {
+      allowJs: true,
+      declaration: true,
+      skipLibCheck: true,
+      strictNullChecks: true,
+      emitDeclarationOnly: true,
+      allowImportingTsExtensions: true,
+      allowNonTsExtensions: true
+    }
+  );
+  relinka("info", "Creating file loaders...");
+  const { loadFile } = createLoader(options);
+  relinka("info", "Processing files with loaders...");
+  const outputs = [];
+  let processedCount = 0;
+  await Promise.all(
+    files.map(async (file) => {
+      const result = await loadFile(file);
+      if (result) {
+        outputs.push(...result);
       }
-      mainSpinner.setText("Scanning input files...");
-      const filePaths = await glob(options.pattern || "**", {
-        absolute: false,
-        ignore: ["**/node_modules", "**/coverage", "**/.git"],
-        cwd: options.srcDir,
-        dot: true,
-        ...options.globOptions
-      });
-      const files = filePaths.map((path) => {
-        const sourcePath = resolve(options.srcDir, path);
-        return {
-          path,
-          srcPath: sourcePath,
-          extension: extname(path),
-          getContents: () => fsp.readFile(sourcePath, { encoding: "utf8" })
-        };
-      });
-      mainSpinner.setText(`Found ${files.length} files to process`);
-      options.typescript ||= {};
-      if (options.typescript.compilerOptions) {
-        mainSpinner.setText("Normalizing TypeScript compiler options...");
-        options.typescript.compilerOptions = await normalizeCompilerOptions(
-          options.typescript.compilerOptions
-        );
+      processedCount++;
+      const shouldUpdate = processedCount % Math.max(1, Math.floor(files.length / 10)) === 0 || processedCount === files.length;
+      if (shouldUpdate) {
+        relinka("verbose", `Processing files: ${file.path} (${processedCount}/${files.length})`);
       }
-      options.typescript.compilerOptions = defu(
-        { noEmit: false },
-        options.typescript.compilerOptions,
-        {
-          allowJs: true,
-          declaration: true,
-          skipLibCheck: true,
-          strictNullChecks: true,
-          emitDeclarationOnly: true,
-          allowImportingTsExtensions: true,
-          allowNonTsExtensions: true
-        }
-      );
-      mainSpinner.setText("Creating file loaders...");
-      const { loadFile } = createLoader(options);
-      mainSpinner.setText("Processing files with loaders...");
-      const outputs = [];
-      let processedCount = 0;
-      await Promise.all(
-        files.map(async (file) => {
-          const result = await loadFile(file);
-          if (result) {
-            outputs.push(...result);
-          }
-          processedCount++;
-          const shouldUpdate = processedCount % Math.max(1, Math.floor(files.length / 10)) === 0 || processedCount === files.length;
-          if (shouldUpdate) {
-            mainSpinner.setProgress({
-              current: processedCount,
-              total: files.length
-            });
-            mainSpinner.setText(`Processing files: ${file.path}`);
-          }
-        })
-      );
-      mainSpinner.setText("Normalizing output extensions...");
-      const pathConflicts = [];
-      for (const output of outputs.filter((o) => o.extension)) {
-        const renamed = basename(output.path, extname(output.path)) + output.extension;
-        output.path = join(dirname(output.path), renamed);
-        const conflictingOutput = outputs.find((o) => o !== output && o.path === output.path);
-        if (conflictingOutput) {
-          pathConflicts.push(output.path);
-        }
+    })
+  );
+  relinka("info", "Normalizing output extensions...");
+  const pathConflicts = [];
+  for (const output of outputs.filter((o) => o.extension)) {
+    const renamed = basename(output.path, extname(output.path)) + output.extension;
+    output.path = join(dirname(output.path), renamed);
+    const conflictingOutput = outputs.find((o) => o !== output && o.path === output.path);
+    if (conflictingOutput) {
+      pathConflicts.push(output.path);
+    }
+  }
+  if (pathConflicts.length > 0) {
+    const errorMessage = `Output path conflict detected for paths: ${pathConflicts.join(", ")}. Multiple files would write to the same output path.`;
+    relinka("error", errorMessage);
+    throw new Error(errorMessage);
+  }
+  const dtsOutputs = outputs.filter((o) => o.declaration && !o.skip);
+  if (dtsOutputs.length > 0) {
+    relinka("info", `Generating TypeScript declarations for ${dtsOutputs.length} files...`);
+    const vfs = new Map(dtsOutputs.map((o) => [o.srcPath, o.contents || ""]));
+    const declarations = /* @__PURE__ */ Object.create(null);
+    for (const loader of [getVueDeclarations, getDeclarations]) {
+      Object.assign(declarations, await loader(vfs, options));
+    }
+    let dtsProcessed = 0;
+    for (const output of dtsOutputs) {
+      const result = declarations[output.srcPath];
+      output.contents = result?.contents || "";
+      if (result.errors) {
+        output.errors = result.errors;
       }
-      if (pathConflicts.length > 0) {
-        const errorMessage = `Output path conflict detected for paths: ${pathConflicts.join(", ")}. Multiple files would write to the same output path.`;
-        mainSpinner.fail(errorMessage);
-        throw new Error(errorMessage);
+      dtsProcessed++;
+      if (dtsProcessed % Math.max(1, Math.floor(dtsOutputs.length / 5)) === 0) {
+        relinka("verbose", `Generated declarations for ${dtsProcessed}/${dtsOutputs.length} files`);
       }
-      const dtsOutputs = outputs.filter((o) => o.declaration && !o.skip);
-      if (dtsOutputs.length > 0) {
-        mainSpinner.setText(`Generating TypeScript declarations for ${dtsOutputs.length} files...`);
-        const vfs = new Map(dtsOutputs.map((o) => [o.srcPath, o.contents || ""]));
-        const declarations = /* @__PURE__ */ Object.create(null);
-        for (const loader of [getVueDeclarations, getDeclarations]) {
-          Object.assign(declarations, await loader(vfs, options));
-        }
-        let dtsProcessed = 0;
-        for (const output of dtsOutputs) {
-          const result = declarations[output.srcPath];
-          output.contents = result?.contents || "";
-          if (result.errors) {
-            output.errors = result.errors;
-          }
-          dtsProcessed++;
-          if (dtsProcessed % Math.max(1, Math.floor(dtsOutputs.length / 5)) === 0) {
-            mainSpinner.setProgress({
-              current: dtsProcessed,
-              total: dtsOutputs.length
-            });
-          }
-        }
+    }
+  }
+  relinka("info", "Resolving relative imports...");
+  const outPaths = new Set(outputs.map((o) => o.path));
+  const resolveId = (from, id = "", resolveExtensions) => {
+    if (!id.startsWith(".")) {
+      return id;
+    }
+    for (const extension of resolveExtensions) {
+      if (outPaths.has(join(dirname(from), id + extension))) {
+        return id + extension;
       }
-      mainSpinner.setText("Resolving relative imports...");
-      const outPaths = new Set(outputs.map((o) => o.path));
-      const resolveId = (from, id = "", resolveExtensions) => {
-        if (!id.startsWith(".")) {
-          return id;
-        }
-        for (const extension of resolveExtensions) {
-          if (outPaths.has(join(dirname(from), id + extension))) {
-            return id + extension;
-          }
+    }
+    return id;
+  };
+  const esmResolveExtensions = ["", "/index.mjs", "/index.js", ".mjs", ".ts", ".js"];
+  const esmOutputs = outputs.filter((o) => o.extension === ".mjs" || o.extension === ".js");
+  for (const output of esmOutputs) {
+    output.contents = output.contents.replace(
+      /(import|export)(\s+(?:.+|{[\s\w,]+})\s+from\s+["'])(.*)(["'])/g,
+      (_, type, head, id, tail) => type + head + resolveId(output.path, id, esmResolveExtensions) + tail
+    ).replace(
+      /import\((["'])(.*)(["'])\)/g,
+      (_, head, id, tail) => "import(" + head + resolveId(output.path, id, esmResolveExtensions) + tail + ")"
+    );
+  }
+  const cjsResolveExtensions = ["", "/index.cjs", ".cjs"];
+  const cjsOutputs = outputs.filter((o) => o.extension === ".cjs");
+  for (const output of cjsOutputs) {
+    output.contents = output.contents.replace(
+      /require\((["'])(.*)(["'])\)/g,
+      (_, head, id, tail) => "require(" + head + resolveId(output.path, id, cjsResolveExtensions) + tail + ")"
+    );
+  }
+  const outputsToWrite = outputs.filter((o) => !o.skip);
+  relinka("info", `Writing ${outputsToWrite.length} output files...`);
+  const writtenFiles = [];
+  const errors = [];
+  let writtenCount = 0;
+  await Promise.all(
+    outputsToWrite.map(async (output) => {
+      try {
+        const outFile = join(options.distDir, output.path);
+        await fsp.mkdir(dirname(outFile), { recursive: true });
+        await (output.raw ? (
+          // @ts-expect-error TODO: fix ts
+          copyFileWithStream(output.srcPath, outFile)
+        ) : (
+          // @ts-expect-error TODO: fix ts
+          fsp.writeFile(outFile, output.contents, "utf8")
+        ));
+        writtenFiles.push(outFile);
+        if (output.errors) {
+          errors.push({ filename: outFile, errors: output.errors });
         }
-        return id;
-      };
-      const esmResolveExtensions = ["", "/index.mjs", "/index.js", ".mjs", ".ts", ".js"];
-      const esmOutputs = outputs.filter((o) => o.extension === ".mjs" || o.extension === ".js");
-      for (const output of esmOutputs) {
-        output.contents = output.contents.replace(
-          /(import|export)(\s+(?:.+|{[\s\w,]+})\s+from\s+["'])(.*)(["'])/g,
-          (_, type, head, id, tail) => type + head + resolveId(output.path, id, esmResolveExtensions) + tail
-        ).replace(
-          /import\((["'])(.*)(["'])\)/g,
-          (_, head, id, tail) => "import(" + head + resolveId(output.path, id, esmResolveExtensions) + tail + ")"
-        );
+      } catch (error) {
+        const errorMessage = `Failed to write file ${output.path}: ${error instanceof Error ? error.message : "Unknown error"}`;
+        errors.push({
+          filename: output.path,
+          errors: [new TypeError(errorMessage)]
+        });
       }
-      const cjsResolveExtensions = ["", "/index.cjs", ".cjs"];
-      const cjsOutputs = outputs.filter((o) => o.extension === ".cjs");
-      for (const output of cjsOutputs) {
-        output.contents = output.contents.replace(
-          /require\((["'])(.*)(["'])\)/g,
-          (_, head, id, tail) => "require(" + head + resolveId(output.path, id, cjsResolveExtensions) + tail + ")"
-        );
+      writtenCount++;
+      const progressUpdateInterval = Math.max(10, Math.floor(outputsToWrite.length / 10));
+      if (writtenCount % progressUpdateInterval === 0 || writtenCount === outputsToWrite.length) {
+        relinka("verbose", `Written ${writtenCount}/${outputsToWrite.length} files`);
       }
-      const outputsToWrite = outputs.filter((o) => !o.skip);
-      mainSpinner.setText(`Writing ${outputsToWrite.length} output files...`);
-      const writtenFiles = [];
-      const errors = [];
-      let writtenCount = 0;
-      await Promise.all(
-        outputsToWrite.map(async (output) => {
-          try {
-            const outFile = join(options.distDir, output.path);
-            await fsp.mkdir(dirname(outFile), { recursive: true });
-            await (output.raw ? (
-              // @ts-expect-error TODO: fix ts
-              copyFileWithStream(output.srcPath, outFile)
-            ) : (
-              // @ts-expect-error TODO: fix ts
-              fsp.writeFile(outFile, output.contents, "utf8")
-            ));
-            writtenFiles.push(outFile);
-            if (output.errors) {
-              errors.push({ filename: outFile, errors: output.errors });
-            }
-          } catch (error) {
-            const errorMessage = `Failed to write file ${output.path}: ${error instanceof Error ? error.message : "Unknown error"}`;
-            errors.push({
-              filename: output.path,
-              errors: [new TypeError(errorMessage)]
-            });
-          }
-          writtenCount++;
-          const progressUpdateInterval = Math.max(10, Math.floor(outputsToWrite.length / 10));
-          if (writtenCount % progressUpdateInterval === 0 || writtenCount === outputsToWrite.length) {
-            mainSpinner.setProgress({
-              current: writtenCount,
-              total: outputsToWrite.length
-            });
-          }
-        })
+    })
+  );
+  const duration = Date.now() - startTime;
+  if (errors.length > 0) {
+    relinka("warn", `Build completed with ${errors.length} errors`);
+    for (const error of errors.slice(0, 5)) {
+      relinka(
+        "error",
+        `Error in ${error.filename}: ${error.errors[0]?.message || "Unknown error"}`
       );
-      if (errors.length > 0) {
-        mainSpinner.warn(`Build completed with ${errors.length} errors`);
-        for (const error of errors.slice(0, 5)) {
-          console.error(`Error in ${error.filename}:`, error.errors[0]?.message || "Unknown error");
-        }
-        if (errors.length > 5) {
-          console.error(`... and ${errors.length - 5} more errors`);
-        }
-      }
-      return {
-        errors,
-        writtenFiles
-      };
-    },
-    {
-      text: "Building using mkdist...",
-      color: "cyan",
-      successText: "Build completed successfully!",
-      failText: "Build failed!"
     }
-  );
+    if (errors.length > 5) {
+      relinka("error", `... and ${errors.length - 5} more errors`);
+    }
+  } else {
+    relinka("success", "Build completed successfully!");
+  }
+  return {
+    result: {
+      errors,
+      writtenFiles
+    },
+    duration
+  };
 }

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

@@ -1,6 +1,5 @@
 import { relative, dirname as pathDirname } from "@reliverse/pathkit";
 import { relinka } from "@reliverse/relinka";
-import { useSpinner } from "@reliverse/rempts";
 import { rmdir, symlink, warn } from "../utils.js";
 import { mkdist } from "./mkdist-impl/make.js";
 export async function mkdistBuild(ctx) {
@@ -8,100 +7,86 @@ export async function mkdistBuild(ctx) {
   if (entries.length === 0) {
     return;
   }
-  await useSpinner.promise(
-    async (mainSpinner) => {
-      await ctx.hooks.callHook("mkdist:entries", ctx, entries);
-      let processedEntries = 0;
-      let totalWrittenFiles = 0;
-      let totalErrors = 0;
-      for (const entry of entries) {
-        processedEntries++;
-        mainSpinner.setProgress({
-          current: processedEntries,
-          total: entries.length
-        });
-        mainSpinner.setText(
-          `Processing entry ${processedEntries}/${entries.length}: ${entry.input}`
-        );
-        const distDir = entry.outDir || entry.input;
-        if (ctx.options.transpileStub) {
-          await rmdir(distDir);
-          await symlink(entry.input, distDir);
-          continue;
-        }
-        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: false,
-          distDir,
-          rootDir: ctx.options.rootDir,
-          srcDir,
-          format: "esm",
-          ext: entry.ext || "js",
-          ...entry
-        };
-        relinka(
-          "info",
-          `[mkdist] Building with options: srcDir=${mkdistOptions.srcDir}, distDir=${mkdistOptions.distDir}, rootDir=${mkdistOptions.rootDir}`
-        );
-        await ctx.hooks.callHook("mkdist:entry:options", ctx, entry, mkdistOptions);
-        try {
-          const { result: output, duration } = await mkdist(mkdistOptions);
-          relinka("verbose", `[mkdist] Entry ${processedEntries} completed in ${duration}ms`);
-          totalWrittenFiles += output.writtenFiles.length;
-          ctx.buildEntries.push({
-            chunks: output.writtenFiles.map((p) => relative(ctx.options.outDir, p)),
-            path: distDir,
-            isLib: ctx.options.isLib
-          });
-          await ctx.hooks.callHook("mkdist:entry:build", ctx, entry, output);
-          if (output.errors && output.errors.length > 0) {
-            totalErrors += output.errors.length;
-            for (const error of output.errors) {
-              warn(
-                ctx,
-                `mkdist build failed for \`${relative(ctx.options.rootDir, error.filename)}\`:
-${error.errors.map((e) => `  - ${e}`).join("\n")}`
-              );
-            }
-          }
-        } catch (error) {
-          totalErrors++;
+  await ctx.hooks.callHook("mkdist:entries", ctx, entries);
+  let processedEntries = 0;
+  let totalWrittenFiles = 0;
+  let totalErrors = 0;
+  relinka("info", `Processing ${entries.length} mkdist entries...`);
+  for (const entry of entries) {
+    processedEntries++;
+    relinka("info", `Processing entry ${processedEntries}/${entries.length}: ${entry.input}`);
+    const distDir = entry.outDir || entry.input;
+    if (ctx.options.transpileStub) {
+      await rmdir(distDir);
+      await symlink(entry.input, distDir);
+      continue;
+    }
+    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: false,
+      distDir,
+      rootDir: ctx.options.rootDir,
+      srcDir,
+      format: "esm",
+      ext: entry.ext || "js",
+      ...entry
+    };
+    relinka(
+      "info",
+      `[mkdist] Building with options: srcDir=${mkdistOptions.srcDir}, distDir=${mkdistOptions.distDir}, rootDir=${mkdistOptions.rootDir}`
+    );
+    await ctx.hooks.callHook("mkdist:entry:options", ctx, entry, mkdistOptions);
+    try {
+      const { result: output, duration } = await mkdist(mkdistOptions);
+      relinka("verbose", `[mkdist] Entry ${processedEntries} completed in ${duration}ms`);
+      totalWrittenFiles += output.writtenFiles.length;
+      ctx.buildEntries.push({
+        chunks: output.writtenFiles.map((p) => relative(ctx.options.outDir, p)),
+        path: distDir,
+        isLib: ctx.options.isLib
+      });
+      await ctx.hooks.callHook("mkdist:entry:build", ctx, entry, output);
+      if (output.errors && output.errors.length > 0) {
+        totalErrors += output.errors.length;
+        for (const error of output.errors) {
           warn(
             ctx,
-            `mkdist build failed for entry ${entry.input}: ${error instanceof Error ? error.message : "Unknown error"}`
+            `mkdist build failed for \`${relative(ctx.options.rootDir, error.filename)}\`:
+${error.errors.map((e) => `  - ${e}`).join("\n")}`
           );
         }
       }
-      await ctx.hooks.callHook("mkdist:done", ctx);
-      if (entries.length > 0 && ctx.options.transpileWatch) {
-        relinka("warn", "`mkdist` builder does not support transpileWatch mode yet.");
-      }
-      if (totalErrors > 0) {
-        mainSpinner.warn(
-          `Processed ${entries.length} entries with ${totalErrors} errors. ${totalWrittenFiles} files written.`
-        );
-      } else {
-        mainSpinner.setText(
-          `Successfully processed ${entries.length} entries. ${totalWrittenFiles} files written.`
-        );
-      }
-    },
-    {
-      text: entries.length === 1 ? "Processing mkdist entry..." : `Processing ${entries.length} mkdist entries...`,
-      color: "blue",
-      successText: entries.length === 1 ? "mkdist entry completed!" : `All ${entries.length} mkdist entries completed!`,
-      failText: "mkdist build failed!",
-      prefixText: "[mkdist]"
+    } catch (error) {
+      totalErrors++;
+      warn(
+        ctx,
+        `mkdist build failed for entry ${entry.input}: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
     }
-  );
+  }
+  await ctx.hooks.callHook("mkdist:done", ctx);
+  if (entries.length > 0 && ctx.options.transpileWatch) {
+    relinka("warn", "`mkdist` builder does not support transpileWatch mode yet.");
+  }
+  if (totalErrors > 0) {
+    relinka(
+      "warn",
+      `Processed ${entries.length} entries with ${totalErrors} errors. ${totalWrittenFiles} files written.`
+    );
+  } else {
+    relinka(
+      "success",
+      `Successfully processed ${entries.length} entries. ${totalWrittenFiles} files written.`
+    );
+  }
 }

package/bin/libs/sdk/sdk-impl/config/info.js

@@ -1,5 +1,5 @@
 import { endPrompt, startPrompt } from "@reliverse/rempts";
-const version = "1.7.62";
+const version = "1.7.64";
 export async function showStartPrompt(isDev) {
   await startPrompt({
     titleColor: "inverse",

package/package.json

@@ -55,7 +55,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.7.62",
+  "version": "1.7.64",
   "keywords": [
     "reliverse",
     "cli",