@reliverse/dler 1.7.153 → 2.0.0

package/bin/impl/utils/exec/exec-error.js

@@ -1,15 +0,0 @@
-export class NonZeroExitError extends Error {
-  result;
-  output;
-  get exitCode() {
-    if (this.result.exitCode !== null) {
-      return this.result.exitCode;
-    }
-    return;
-  }
-  constructor(result, output) {
-    super(`Process exited with non-zero status (${result.exitCode})`);
-    this.result = result;
-    this.output = output;
-  }
-}

package/bin/impl/utils/exec/exec-escape.d.ts

@@ -1,2 +0,0 @@
-export declare function escapeCommand(arg: string): string;
-export declare function escapeArgument(arg: string, doubleEscapeMetaChars?: boolean): string;

package/bin/impl/utils/exec/exec-escape.js

@@ -1,15 +0,0 @@
-const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
-export function escapeCommand(arg) {
-  return arg.replace(metaCharsRegExp, "^$1");
-}
-export function escapeArgument(arg, doubleEscapeMetaChars) {
-  let result = `${arg}`;
-  result = result.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
-  result = result.replace(/(?=(\\+?)?)\1$/, "$1$1");
-  result = `"${result}"`;
-  result = result.replace(metaCharsRegExp, "^$1");
-  if (doubleEscapeMetaChars) {
-    result = result.replace(metaCharsRegExp, "^$1");
-  }
-  return result;
-}

package/bin/impl/utils/exec/exec-mod.d.ts

@@ -1,58 +0,0 @@
-import { type ChildProcess, type SpawnOptions } from "node:child_process";
-import type { Readable } from "node:stream";
-export interface Output {
-    stderr: string;
-    stdout: string;
-    exitCode: number | undefined;
-}
-export interface PipeOptions extends Options {
-}
-export type KillSignal = Parameters<ChildProcess["kill"]>[0];
-export interface OutputApi extends AsyncIterable<string> {
-    pipe(command: string, args?: string[], options?: Partial<PipeOptions>): Result;
-    process: ChildProcess | undefined;
-    kill(signal?: KillSignal): boolean;
-    get pid(): number | undefined;
-    get aborted(): boolean;
-    get killed(): boolean;
-    get exitCode(): number | undefined;
-}
-export type Result = PromiseLike<Output> & OutputApi;
-export interface Options {
-    signal?: AbortSignal;
-    nodeOptions?: SpawnOptions;
-    timeout?: number;
-    persist?: boolean;
-    stdin?: ExecProcess;
-    throwOnError?: boolean;
-}
-export type XExec = (command: string, args?: string[], options?: Partial<Options>) => Result;
-export declare class ExecProcess implements Result {
-    protected _process?: ChildProcess;
-    protected _aborted: boolean;
-    protected _options: Partial<Options>;
-    protected _command: string;
-    protected _args: string[];
-    protected _resolveClose?: () => void;
-    protected _processClosed: Promise<void>;
-    protected _thrownError?: Error;
-    get process(): ChildProcess | undefined;
-    get pid(): number | undefined;
-    get exitCode(): number | undefined;
-    constructor(command: string, args?: string[], options?: Partial<Options>);
-    kill(signal?: KillSignal): boolean;
-    get aborted(): boolean;
-    get killed(): boolean;
-    pipe(command: string, args?: string[], options?: Partial<PipeOptions>): Result;
-    [Symbol.asyncIterator](): AsyncIterator<string>;
-    protected _waitForOutput(): Promise<Output>;
-    then<TResult1 = Output, TResult2 = never>(onfulfilled?: ((value: Output) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
-    protected _streamOut?: Readable;
-    protected _streamErr?: Readable;
-    spawn(): void;
-    protected _resetState(): void;
-    protected _onError: (err: Error) => void;
-    protected _onClose: () => void;
-}
-export declare const x: XExec;
-export declare const exec: XExec;

package/bin/impl/utils/exec/exec-mod.js

@@ -1,224 +0,0 @@
-import { spawn } from "node:child_process";
-import { normalize as normalizePath } from "node:path";
-import { cwd as getCwd } from "node:process";
-import readline from "node:readline";
-import { computeEnv } from "./exec-env.js";
-import { NonZeroExitError } from "./exec-error.js";
-import { combineStreams } from "./exec-stream.js";
-import { _parse } from "./exec-types.js";
-const defaultOptions = {
-  timeout: void 0,
-  persist: false
-};
-const defaultNodeOptions = {
-  windowsHide: true
-};
-function normaliseCommandAndArgs(command, args) {
-  const normalisedPath = normalizePath(command);
-  const normalisedArgs = args ?? [];
-  return {
-    command: normalisedPath,
-    args: normalisedArgs
-  };
-}
-function combineSignals(signals) {
-  const controller = new AbortController();
-  for (const signal of signals) {
-    if (signal.aborted) {
-      controller.abort();
-      return signal;
-    }
-    const onAbort = () => {
-      controller.abort(signal.reason);
-    };
-    signal.addEventListener("abort", onAbort, {
-      signal: controller.signal
-    });
-  }
-  return controller.signal;
-}
-export class ExecProcess {
-  _process;
-  _aborted = false;
-  _options;
-  _command;
-  _args;
-  _resolveClose;
-  _processClosed;
-  _thrownError;
-  get process() {
-    return this._process;
-  }
-  get pid() {
-    return this._process?.pid;
-  }
-  get exitCode() {
-    if (this._process && this._process.exitCode !== null) {
-      return this._process.exitCode;
-    }
-    return;
-  }
-  constructor(command, args, options) {
-    this._options = {
-      ...defaultOptions,
-      ...options
-    };
-    this._command = command;
-    this._args = args ?? [];
-    this._processClosed = new Promise((resolve) => {
-      this._resolveClose = resolve;
-    });
-  }
-  kill(signal) {
-    return this._process?.kill(signal) === true;
-  }
-  get aborted() {
-    return this._aborted;
-  }
-  get killed() {
-    return this._process?.killed === true;
-  }
-  pipe(command, args, options) {
-    return exec(command, args, {
-      ...options,
-      stdin: this
-    });
-  }
-  async *[Symbol.asyncIterator]() {
-    const proc = this._process;
-    if (!proc) {
-      return;
-    }
-    const streams = [];
-    if (this._streamErr) {
-      streams.push(this._streamErr);
-    }
-    if (this._streamOut) {
-      streams.push(this._streamOut);
-    }
-    const streamCombined = combineStreams(streams);
-    const rl = readline.createInterface({
-      input: streamCombined
-    });
-    for await (const chunk of rl) {
-      yield chunk.toString();
-    }
-    await this._processClosed;
-    proc.removeAllListeners();
-    if (this._thrownError) {
-      throw this._thrownError;
-    }
-    if (this._options?.throwOnError && this.exitCode !== 0 && this.exitCode !== void 0) {
-      throw new NonZeroExitError(this);
-    }
-  }
-  async _waitForOutput() {
-    const proc = this._process;
-    if (!proc) {
-      throw new Error("No process was started");
-    }
-    let stderr = "";
-    let stdout = "";
-    if (this._streamOut) {
-      for await (const chunk of this._streamOut) {
-        stdout += chunk.toString();
-      }
-    }
-    if (this._streamErr) {
-      for await (const chunk of this._streamErr) {
-        stderr += chunk.toString();
-      }
-    }
-    await this._processClosed;
-    if (this._options?.stdin) {
-      await this._options.stdin;
-    }
-    proc.removeAllListeners();
-    if (this._thrownError) {
-      throw this._thrownError;
-    }
-    const result = {
-      stderr,
-      stdout,
-      exitCode: this.exitCode
-    };
-    if (this._options.throwOnError && this.exitCode !== 0 && this.exitCode !== void 0) {
-      throw new NonZeroExitError(this, result);
-    }
-    return result;
-  }
-  then(onfulfilled, onrejected) {
-    return this._waitForOutput().then(onfulfilled, onrejected);
-  }
-  _streamOut;
-  _streamErr;
-  spawn() {
-    const cwd = getCwd();
-    const options = this._options;
-    const nodeOptions = {
-      ...defaultNodeOptions,
-      ...options.nodeOptions
-    };
-    const signals = [];
-    this._resetState();
-    if (options.timeout !== void 0) {
-      signals.push(AbortSignal.timeout(options.timeout));
-    }
-    if (options.signal !== void 0) {
-      signals.push(options.signal);
-    }
-    if (options.persist === true) {
-      nodeOptions.detached = true;
-    }
-    if (signals.length > 0) {
-      nodeOptions.signal = combineSignals(signals);
-    }
-    nodeOptions.env = computeEnv(cwd, nodeOptions.env);
-    const { command: normalisedCommand, args: normalisedArgs } = normaliseCommandAndArgs(
-      this._command,
-      this._args
-    );
-    const crossResult = _parse(normalisedCommand, normalisedArgs, nodeOptions);
-    const handle = spawn(crossResult.command, crossResult.args, crossResult.options);
-    if (handle.stderr) {
-      this._streamErr = handle.stderr;
-    }
-    if (handle.stdout) {
-      this._streamOut = handle.stdout;
-    }
-    this._process = handle;
-    handle.once("error", this._onError);
-    handle.once("close", this._onClose);
-    if (options.stdin !== void 0 && handle.stdin && options.stdin.process) {
-      const { stdout } = options.stdin.process;
-      if (stdout) {
-        stdout.pipe(handle.stdin);
-      }
-    }
-  }
-  _resetState() {
-    this._aborted = false;
-    this._processClosed = new Promise((resolve) => {
-      this._resolveClose = resolve;
-    });
-    this._thrownError = void 0;
-  }
-  _onError = (err) => {
-    if (err.name === "AbortError" && (!(err.cause instanceof Error) || err.cause.name !== "TimeoutError")) {
-      this._aborted = true;
-      return;
-    }
-    this._thrownError = err;
-  };
-  _onClose = () => {
-    if (this._resolveClose) {
-      this._resolveClose();
-    }
-  };
-}
-export const x = (command, args, userOptions) => {
-  const proc = new ExecProcess(command, args, userOptions);
-  proc.spawn();
-  return proc;
-};
-export const exec = x;

package/bin/impl/utils/exec/exec-parse.d.ts

@@ -1,2 +0,0 @@
-import type { ExecParseResult } from "./exec-types.js";
-export declare function parse(command: string, args?: string[] | any, options?: any): Promise<ExecParseResult>;

package/bin/impl/utils/exec/exec-parse.js

@@ -1,71 +0,0 @@
-import path from "node:path";
-import { escapeArgument, escapeCommand } from "./exec-escape.js";
-import { resolveCommand } from "./exec-resolve.js";
-import { readShebang } from "./exec-shebang.js";
-const isWin = process.platform === "win32";
-const isExecutableRegExp = /\.(?:com|exe)$/i;
-const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
-async function detectShebang(parsed) {
-  parsed.file = await resolveCommand(parsed);
-  if (parsed.file) {
-    const shebang = readShebang(parsed.file);
-    if (shebang) {
-      parsed.args.unshift(parsed.file);
-      parsed.command = shebang;
-      return await resolveCommand(parsed);
-    }
-  }
-  return parsed.file;
-}
-async function parseNonShell(parsed) {
-  if (!isWin) return parsed;
-  const commandFile = await detectShebang(parsed);
-  const needsShell = !isExecutableRegExp.test(commandFile ?? "");
-  if (parsed.options.forceShell || needsShell) {
-    const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile ?? "");
-    let cmd = path.normalize(parsed.command);
-    cmd = escapeCommand(cmd);
-    const args = parsed.args.map((arg) => escapeArgument(arg, needsDoubleEscapeMetaChars));
-    const shellCommand = [cmd].concat(args).join(" ");
-    parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
-    parsed.command = process.env.comspec || "cmd.exe";
-    parsed.options.windowsVerbatimArguments = true;
-  }
-  return parsed;
-}
-export async function parse(command, args, options) {
-  console.log("DEBUG: parse function called with:", {
-    command,
-    args,
-    options,
-    commandType: typeof command,
-    argsType: typeof args,
-    isArgsArray: Array.isArray(args)
-  });
-  let actualArgs = args;
-  let actualOptions = options;
-  if (actualArgs && !Array.isArray(actualArgs)) {
-    actualOptions = actualArgs;
-    actualArgs = null;
-  }
-  actualArgs = actualArgs ? actualArgs.slice(0) : [];
-  actualOptions = { ...actualOptions };
-  const parsed = {
-    command,
-    args: actualArgs,
-    options: actualOptions,
-    file: void 0,
-    original: {
-      command,
-      args: actualArgs
-    }
-  };
-  console.log("DEBUG: parse function returning:", {
-    command: parsed.command,
-    args: parsed.args,
-    commandType: typeof parsed.command,
-    argsType: typeof parsed.args,
-    isArgsArray: Array.isArray(parsed.args)
-  });
-  return actualOptions.shell ? parsed : await parseNonShell(parsed);
-}

package/bin/impl/utils/exec/exec-resolve.d.ts

@@ -1,2 +0,0 @@
-import type { ExecParseResult } from "./exec-types.js";
-export declare function resolveCommand(parsed: ExecParseResult): Promise<string | undefined>;

package/bin/impl/utils/exec/exec-resolve.js

@@ -1,39 +0,0 @@
-import path from "node:path";
-import { lookpath } from "lookpath";
-import getPathKey from "path-key";
-async function resolveCommandAttempt(parsed, withoutPathExt) {
-  const env = parsed.options.env || process.env;
-  const cwd = process.cwd();
-  const hasCustomCwd = parsed.options.cwd != null;
-  const shouldSwitchCwd = hasCustomCwd && typeof process.chdir === "function" && !process.chdir.disabled;
-  if (shouldSwitchCwd) {
-    try {
-      process.chdir(String(parsed.options.cwd ?? cwd));
-    } catch {
-    }
-  }
-  let resolved;
-  try {
-    const pathEnv = env[getPathKey({ env })];
-    const lookpathOptions = {
-      path: pathEnv?.split(path.delimiter),
-      include: withoutPathExt ? [] : void 0
-    };
-    resolved = await lookpath(parsed.command, lookpathOptions);
-  } catch {
-  } finally {
-    if (shouldSwitchCwd) {
-      process.chdir(cwd);
-    }
-  }
-  if (resolved) {
-    resolved = path.resolve(
-      hasCustomCwd ? String(parsed.options.cwd ?? cwd) : cwd,
-      typeof resolved === "string" ? resolved : String(resolved)
-    );
-  }
-  return resolved;
-}
-export async function resolveCommand(parsed) {
-  return await resolveCommandAttempt(parsed) || await resolveCommandAttempt(parsed, true);
-}

package/bin/impl/utils/exec/exec-shebang.d.ts

@@ -1 +0,0 @@
-export declare function readShebang(command: string): string | null;

package/bin/impl/utils/exec/exec-shebang.js

@@ -1,14 +0,0 @@
-import fs from "node:fs";
-import shebangCommand from "shebang-command";
-export function readShebang(command) {
-  const size = 150;
-  const buffer = Buffer.alloc(size);
-  let fd;
-  try {
-    fd = fs.openSync(command, "r");
-    fs.readSync(fd, buffer, 0, size, 0);
-    fs.closeSync(fd);
-  } catch {
-  }
-  return shebangCommand(buffer.toString());
-}

package/bin/impl/utils/exec/exec-spawn.d.ts

@@ -1,3 +0,0 @@
-import { type ChildProcess, type SpawnOptions, type SpawnSyncReturns } from "node:child_process";
-export declare function spawn(command: string, args?: string[], options?: SpawnOptions): Promise<ChildProcess>;
-export declare function spawnSync(command: string, args?: string[], options?: SpawnOptions): Promise<SpawnSyncReturns<string | Buffer<ArrayBufferLike>>>;

package/bin/impl/utils/exec/exec-spawn.js

@@ -1,18 +0,0 @@
-import {
-  spawn as nodeSpawn,
-  spawnSync as nodeSpawnSync
-} from "node:child_process";
-import { hookChildProcess, verifyENOENTSync } from "./exec-enoent.js";
-import { parse } from "./exec-parse.js";
-export async function spawn(command, args, options) {
-  const parsed = await parse(command, args, options);
-  const spawned = nodeSpawn(parsed.command, parsed.args, parsed.options);
-  hookChildProcess(spawned, parsed);
-  return spawned;
-}
-export async function spawnSync(command, args, options) {
-  const parsed = await parse(command, args, options);
-  const result = nodeSpawnSync(parsed.command, parsed.args, parsed.options);
-  result.error = result.error || verifyENOENTSync(result.status, parsed);
-  return result;
-}

package/bin/impl/utils/exec/exec-stream.d.ts

@@ -1,4 +0,0 @@
-import type { EventEmitter } from "node:events";
-import { type Readable } from "node:stream";
-export declare const waitForEvent: (emitter: EventEmitter, name: string) => Promise<void>;
-export declare const combineStreams: (streams: Readable[]) => Readable;

package/bin/impl/utils/exec/exec-stream.js

@@ -1,18 +0,0 @@
-import { PassThrough } from "node:stream";
-export const waitForEvent = (emitter, name) => new Promise((resolve) => {
-  emitter.on(name, resolve);
-});
-export const combineStreams = (streams) => {
-  let streamCount = streams.length;
-  const combined = new PassThrough();
-  const maybeEmitEnd = () => {
-    if (--streamCount === 0) {
-      combined.emit("end");
-    }
-  };
-  for (const stream of streams) {
-    stream.pipe(combined, { end: false });
-    stream.on("end", maybeEmitEnd);
-  }
-  return combined;
-};

package/bin/impl/utils/exec/exec-types.d.ts

@@ -1,13 +0,0 @@
-import type { ChildProcess, SpawnOptions } from "node:child_process";
-export type { ChildProcess, SpawnOptions };
-export interface ExecParseResult {
-    command: string;
-    args: string[];
-    options: SpawnOptions;
-    file?: string;
-    original: {
-        command: string;
-        args: string[];
-    };
-}
-export declare function _parse(file: string, args: string[], options?: SpawnOptions): ExecParseResult;

package/bin/impl/utils/exec/exec-types.js

@@ -1,9 +0,0 @@
-export function _parse(file, args, options) {
-  return {
-    command: file,
-    args,
-    options: options ?? {},
-    file,
-    original: { command: file, args }
-  };
-}

package/bin/impl/utils/file-type.d.ts

@@ -1,21 +0,0 @@
-import { type FileTypeResult } from "file-type";
-/**
- * Detect file type from a file path
- */
-export declare function detectFileType(filePath: string): Promise<FileTypeResult | undefined>;
-/**
- * Detect file type from a buffer
- */
-export declare function detectBufferType(buffer: Uint8Array | ArrayBuffer): Promise<FileTypeResult | undefined>;
-/**
- * Detect file type from a stream
- */
-export declare function detectStreamType(stream: ReadableStream<Uint8Array>): Promise<FileTypeResult | undefined>;
-/**
- * Check if a file is binary using both file-type and BINARY_EXTS
- */
-export declare function isBinary(filePath: string): Promise<boolean>;
-/**
- * Get MIME type for a file using both file-type and BINARY_EXTS
- */
-export declare function getMimeType(filePath: string): Promise<string | undefined>;

package/bin/impl/utils/file-type.js

@@ -1,78 +0,0 @@
-import path from "@reliverse/pathkit";
-import {
-  fileTypeFromBuffer,
-  fileTypeFromFile,
-  fileTypeFromStream
-} from "file-type";
-import { BINARY_SET } from "./b-exts.js";
-export async function detectFileType(filePath) {
-  try {
-    const result = await fileTypeFromFile(filePath);
-    if (result) return result;
-    const ext = path.extname(filePath).slice(1).toLowerCase();
-    if (BINARY_SET.has(ext)) {
-      return {
-        ext,
-        mime: `application/${ext}`
-        // Generic MIME type as fallback
-      };
-    }
-    return;
-  } catch {
-    const ext = path.extname(filePath).slice(1).toLowerCase();
-    if (BINARY_SET.has(ext)) {
-      return {
-        ext,
-        mime: `application/${ext}`
-        // Generic MIME type as fallback
-      };
-    }
-    return;
-  }
-}
-export async function detectBufferType(buffer) {
-  try {
-    const result = await fileTypeFromBuffer(buffer);
-    if (result) return result;
-    return;
-  } catch {
-    return;
-  }
-}
-export async function detectStreamType(stream) {
-  try {
-    const result = await fileTypeFromStream(stream);
-    if (result) return result;
-    return;
-  } catch {
-    return;
-  }
-}
-export async function isBinary(filePath) {
-  try {
-    const result = await fileTypeFromFile(filePath);
-    if (result) return true;
-    const ext = path.extname(filePath).slice(1).toLowerCase();
-    return BINARY_SET.has(ext);
-  } catch {
-    const ext = path.extname(filePath).slice(1).toLowerCase();
-    return BINARY_SET.has(ext);
-  }
-}
-export async function getMimeType(filePath) {
-  try {
-    const result = await fileTypeFromFile(filePath);
-    if (result?.mime) return result.mime;
-    const ext = path.extname(filePath).slice(1).toLowerCase();
-    if (BINARY_SET.has(ext)) {
-      return `application/${ext}`;
-    }
-    return;
-  } catch {
-    const ext = path.extname(filePath).slice(1).toLowerCase();
-    if (BINARY_SET.has(ext)) {
-      return `application/${ext}`;
-    }
-    return;
-  }
-}

package/bin/impl/utils/finalize.d.ts

@@ -1,10 +0,0 @@
-import type { LibConfig } from "../schema/mod.js";
-import type { PerfTimer } from "../types/mod.js";
-/**
- * Finalizes the build process and reports completion.
- */
-export declare function finalizeBuild(shouldShowSpinner: boolean, timer: PerfTimer, commonPubPause: boolean, usedMode: "build" | "pub"): Promise<void>;
-/**
- * Finalizes the publish process, cleans up, and reports completion.
- */
-export declare function finalizePub(libsList: Record<string, LibConfig>, distNpmDirName: string, distJsrDirName: string, libsDirDist: string): Promise<void>;

package/bin/impl/utils/finalize.js

@@ -1,33 +0,0 @@
-import { setBumpDisabledValueTo } from "@reliverse/bleump";
-import { relinka } from "@reliverse/relinka";
-import prettyMilliseconds from "pretty-ms";
-import { removeDistFolders } from "./utils-clean.js";
-import { getElapsedPerfTime } from "./utils-perf.js";
-function providePublishGuidance(usedMode, commonPubPause) {
-  if (commonPubPause) {
-    relinka("info", "\u{1F4DD} Publishing is paused in your config (commonPubPause=true)");
-    relinka(
-      "info",
-      usedMode === "pub" ? "\u{1F4A1} To enable publishing: set commonPubPause=false in your config" : "\u{1F4A1} To publish: set commonPubPause=false, then run: rse publish"
-    );
-  } else {
-    relinka("info", "For publishing to NPM/JSR, use: rse publish");
-  }
-}
-export async function finalizeBuild(shouldShowSpinner, timer, commonPubPause, usedMode) {
-  if (!shouldShowSpinner) {
-    const elapsedTime = getElapsedPerfTime(timer);
-    const formattedPerfTime = prettyMilliseconds(elapsedTime, { verbose: true });
-    console.log("\n" + "=".repeat(60));
-    relinka("verbose", `\u2705 Build completed successfully in ${formattedPerfTime}`);
-  }
-  providePublishGuidance(usedMode, commonPubPause);
-}
-export async function finalizePub(libsList, distNpmDirName, distJsrDirName, libsDirDist) {
-  await removeDistFolders(distNpmDirName, distJsrDirName, libsDirDist, libsList);
-  try {
-    await setBumpDisabledValueTo(false);
-  } catch {
-    throw new Error("[reliverse.ts] Failed to set bumpDisable to false");
-  }
-}

package/bin/impl/utils/finish-text.d.ts

@@ -1,6 +0,0 @@
-import type { ReliverseConfig } from "../schema/mod";
-import type { PerfTimer } from "../types/mod";
-export declare function createCompletionTexts(buildConfig: ReliverseConfig, timer: PerfTimer, action: "build" | "publish"): Promise<{
-    plain: string;
-    withEmoji: string;
-}>;