@reliverse/dler 1.7.16 → 1.7.17

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

@@ -5,129 +5,209 @@ import { glob } from "tinyglobby";
 import { createLoader } from "./loader.js";
 import { getDeclarations, normalizeCompilerOptions } from "./utils/dts.js";
 import { copyFileWithStream } from "./utils/fs.js";
+import { useSpinner } from "./utils/spinner.js";
 import { getVueDeclarations } from "./utils/vue-dts.js";
 export async function mkdist(options = {}) {
-  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) {
-    await fsp.unlink(options.distDir).catch(() => {
-    });
-    await fsp.rm(options.distDir, { recursive: true, force: true });
-    await fsp.mkdir(options.distDir, { recursive: true });
-  }
-  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" })
-    };
-  });
-  options.typescript ||= {};
-  if (options.typescript.compilerOptions) {
-    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
-    }
-  );
-  const { loadFile } = createLoader(options);
-  const outputs = [];
-  for (const file of files) {
-    outputs.push(...await loadFile(file) || []);
-  }
-  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);
-    if (outputs.some((o) => o !== output && o.path === output.path)) {
-      output.skip = true;
-    }
-  }
-  const dtsOutputs = outputs.filter((o) => o.declaration && !o.skip);
-  if (dtsOutputs.length > 0) {
-    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));
-    }
-    for (const output of dtsOutputs) {
-      const result = declarations[output.srcPath];
-      output.contents = result?.contents || "";
-      if (result.errors) {
-        output.errors = result.errors;
+  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 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("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
+        );
       }
-    }
-    return id;
-  };
-  const esmResolveExtensions = ["", "/index.mjs", "/index.js", ".mjs", ".ts", ".js"];
-  for (const output of outputs.filter((o) => o.extension === ".mjs" || o.extension === ".js")) {
-    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"];
-  for (const output of outputs.filter((o) => o.extension === ".cjs")) {
-    output.contents = output.contents.replace(
-      /require\((["'])(.*)(["'])\)/g,
-      (_, head, id, tail) => "require(" + head + resolveId(output.path, id, cjsResolveExtensions) + tail + ")"
-    );
-  }
-  const writtenFiles = [];
-  const errors = [];
-  await Promise.all(
-    outputs.filter((o) => !o.skip).map(async (output) => {
-      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 });
+      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);
+        }
       }
-    })
+      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);
+      }
+      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
+            });
+          }
+        }
+      }
+      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);
+      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
+            });
+          }
+        })
+      );
+      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: "Starting mkdist build...",
+      color: "cyan",
+      successText: "Build completed successfully!",
+      failText: "Build failed!"
+    }
   );
-  return {
-    errors,
-    writtenFiles
-  };
 }

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

@@ -0,0 +1,99 @@
+import { type Color, type Options as OraOptions } from "ora";
+interface SpinnerOptions {
+    text: string;
+    color?: Color;
+    spinner?: OraOptions["spinner"];
+    successText?: string;
+    failText?: string;
+    prefixText?: string;
+    silent?: boolean;
+    hideCursor?: boolean;
+}
+interface ProgressOptions {
+    current: number;
+    total: number;
+    format?: "percentage" | "count" | "both";
+}
+interface SpinnerControls {
+    start: (text?: string) => SpinnerControls;
+    stop: () => void;
+    setText: (text: string) => void;
+    setProgress: (progress: ProgressOptions) => void;
+    succeed: (text?: string) => void;
+    fail: (text?: string) => void;
+    warn: (text?: string) => void;
+    info: (text?: string) => void;
+    isSpinning: () => boolean;
+    clear: () => void;
+    getElapsedTime: () => number;
+    pause: () => void;
+    resume: () => void;
+    dispose: () => void;
+}
+/**
+ * Creates a terminal spinner with enhanced controls and styling options.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const spinner = useSpinner({ text: "Loading..." }).start();
+ * spinner.stop();
+ *
+ * // With progress tracking
+ * const spinner = useSpinner({ text: "Processing files..." }).start();
+ * for (let i = 0; i < files.length; i++) {
+ *   spinner.setProgress({ current: i + 1, total: files.length });
+ *   await processFile(files[i]);
+ * }
+ * spinner.succeed();
+ *
+ * // With custom color and spinner
+ * const spinner = useSpinner({
+ *   text: "Processing...",
+ *   color: "cyan",
+ *   spinner: "dots"
+ * }).start();
+ *
+ * // With success/failure states
+ * const spinner = useSpinner({
+ *   text: "Uploading...",
+ *   successText: "Upload complete!",
+ *   failText: "Upload failed!"
+ * }).start();
+ * try {
+ *   await uploadFile();
+ *   spinner.succeed();
+ * } catch (error) {
+ *   spinner.fail();
+ * }
+ *
+ * // Using the wrapper for async operations
+ * await useSpinner.promise(
+ *   async (spinner) => {
+ *     await longOperation();
+ *     spinner.setProgress({ current: 50, total: 100 });
+ *   },
+ *   {
+ *     text: "Working...",
+ *     successText: "Done!",
+ *     failText: "Failed!"
+ *   }
+ * );
+ * ```
+ */
+export declare function useSpinner(options: SpinnerOptions): SpinnerControls;
+export declare namespace useSpinner {
+    var promise: <T>(operation: (spinner: SpinnerControls) => Promise<T>, options: SpinnerOptions) => Promise<T>;
+    var nested: (parentOptions: SpinnerOptions) => {
+        start: () => {
+            child: (childOptions: SpinnerOptions) => SpinnerControls;
+            finish: (success: boolean, text?: string) => void;
+            dispose: () => void;
+        };
+    };
+    var withTiming: <T>(operation: (spinner: SpinnerControls) => Promise<T>, options: SpinnerOptions) => Promise<{
+        result: T;
+        duration: number;
+    }>;
+}
+export {};

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

@@ -0,0 +1,206 @@
+import ora from "ora";
+function isInteractive() {
+  return process.stdout.isTTY && !process.env.CI && !process.env.GITHUB_ACTIONS && !process.env.GITLAB_CI && !process.env.BUILDKITE && process.env.TERM !== "dumb";
+}
+function formatProgress(options) {
+  const { current, total, format = "both" } = options;
+  const percentage = Math.round(current / total * 100);
+  switch (format) {
+    case "percentage":
+      return `${percentage}%`;
+    case "count":
+      return `${current}/${total}`;
+    case "both":
+      return `${current}/${total} (${percentage}%)`;
+    default:
+      return `${current}/${total}`;
+  }
+}
+export function useSpinner(options) {
+  let spinnerInstance = null;
+  const interactive = isInteractive();
+  const state = {
+    isActive: false,
+    isPaused: false,
+    startTime: null,
+    pausedTime: 0,
+    text: options.text
+  };
+  const controls = {
+    start: (text) => {
+      if (text) {
+        options.text = text;
+        state.text = text;
+      }
+      if (options.silent || !interactive) {
+        console.log(options.prefixText ? `${options.prefixText} ${options.text}` : options.text);
+        state.isActive = true;
+        state.startTime = Date.now();
+        return controls;
+      }
+      if (!spinnerInstance) {
+        spinnerInstance = ora({
+          text: options.text,
+          color: options.color,
+          spinner: options.spinner,
+          hideCursor: options.hideCursor,
+          prefixText: options.prefixText
+        });
+      } else {
+        spinnerInstance.text = options.text;
+      }
+      spinnerInstance.start();
+      state.isActive = true;
+      state.startTime = Date.now();
+      return controls;
+    },
+    stop: () => {
+      if (spinnerInstance) {
+        spinnerInstance.stop();
+      }
+      state.isActive = false;
+    },
+    setText: (text) => {
+      state.text = text;
+      if (spinnerInstance && !state.isPaused) {
+        spinnerInstance.text = text;
+      } else if (options.silent || !interactive) {
+        console.log(options.prefixText ? `${options.prefixText} ${text}` : text);
+      }
+      options.text = text;
+    },
+    setProgress: (progress) => {
+      const progressText = formatProgress(progress);
+      const newText = `${state.text} [${progressText}]`;
+      if (spinnerInstance && !state.isPaused) {
+        spinnerInstance.text = newText;
+      } else if (options.silent || !interactive) {
+        console.log(options.prefixText ? `${options.prefixText} ${newText}` : newText);
+      }
+    },
+    succeed: (text) => {
+      const successText = text ?? options.successText ?? state.text;
+      if (spinnerInstance) {
+        spinnerInstance.succeed(successText);
+      } else {
+        console.log(`\u2713 ${successText}`);
+      }
+      state.isActive = false;
+    },
+    fail: (text) => {
+      const failText = text ?? options.failText ?? state.text;
+      if (spinnerInstance) {
+        spinnerInstance.fail(failText);
+      } else {
+        console.error(`\u2717 ${failText}`);
+      }
+      state.isActive = false;
+    },
+    warn: (text) => {
+      const warnText = text ?? state.text;
+      if (spinnerInstance) {
+        spinnerInstance.warn(warnText);
+      } else {
+        console.warn(`\u26A0 ${warnText}`);
+      }
+    },
+    info: (text) => {
+      const infoText = text ?? state.text;
+      if (spinnerInstance) {
+        spinnerInstance.info(infoText);
+      } else {
+        console.info(`\u2139 ${infoText}`);
+      }
+    },
+    isSpinning: () => {
+      return state.isActive && !state.isPaused;
+    },
+    clear: () => {
+      if (spinnerInstance) {
+        spinnerInstance.clear();
+      }
+    },
+    getElapsedTime: () => {
+      if (!state.startTime) return 0;
+      const currentTime = Date.now();
+      return currentTime - state.startTime - state.pausedTime;
+    },
+    pause: () => {
+      if (state.isActive && !state.isPaused) {
+        if (spinnerInstance) {
+          spinnerInstance.stop();
+        }
+        state.isPaused = true;
+      }
+    },
+    resume: () => {
+      if (state.isActive && state.isPaused) {
+        if (spinnerInstance) {
+          spinnerInstance.start();
+        }
+        state.isPaused = false;
+      }
+    },
+    dispose: () => {
+      if (spinnerInstance) {
+        spinnerInstance.stop();
+        spinnerInstance = null;
+      }
+      state.isActive = false;
+      state.isPaused = false;
+    }
+  };
+  return controls;
+}
+useSpinner.promise = async (operation, options) => {
+  const spinner = useSpinner(options).start();
+  try {
+    const result = await operation(spinner);
+    spinner.succeed();
+    return result;
+  } catch (error) {
+    spinner.fail();
+    throw error;
+  } finally {
+    spinner.dispose();
+  }
+};
+useSpinner.nested = (parentOptions) => {
+  const parentSpinner = useSpinner({
+    ...parentOptions,
+    silent: true
+    // Parent is silent, children will show progress
+  });
+  return {
+    start: () => {
+      parentSpinner.start();
+      return {
+        child: (childOptions) => useSpinner(childOptions),
+        finish: (success, text) => {
+          if (success) {
+            parentSpinner.succeed(text);
+          } else {
+            parentSpinner.fail(text);
+          }
+        },
+        dispose: () => parentSpinner.dispose()
+      };
+    }
+  };
+};
+useSpinner.withTiming = async (operation, options) => {
+  const spinner = useSpinner(options).start();
+  const startTime = Date.now();
+  try {
+    const result = await operation(spinner);
+    const duration = Date.now() - startTime;
+    spinner.succeed(`${options.successText || options.text} (${duration}ms)`);
+    return { result, duration };
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    spinner.fail(`${options.failText || options.text} (failed after ${duration}ms)`);
+    throw error;
+  } finally {
+    spinner.dispose();
+  }
+};