@reliverse/dler 1.7.91 → 1.7.93

package/bin/libs/sdk/sdk-impl/utils/agg/agg-3.js

@@ -1,197 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-export function buildPathRelative(filePath, inputDir, stripPrefix) {
-  let resolved = path.resolve(filePath);
-  const resolvedStrip = stripPrefix ? path.resolve(stripPrefix) : "";
-  if (resolvedStrip && resolved.startsWith(resolvedStrip)) {
-    resolved = resolved.slice(resolvedStrip.length);
-  } else {
-    resolved = path.relative(path.resolve(inputDir), resolved);
-  }
-  while (resolved.startsWith(path.sep)) {
-    resolved = resolved.slice(1);
-  }
-  resolved = resolved.replace(/\\/g, "/");
-  if (resolved.toLowerCase().endsWith(".ts")) {
-    resolved = `${resolved.slice(0, -3)}.js`;
-  }
-  if (!resolved.startsWith("./") && !resolved.startsWith("../")) {
-    resolved = `./${resolved}`;
-  }
-  resolved = resolved.replace(/\/+/g, "/");
-  return resolved;
-}
-export async function collectFiles(dir, exts, recursive, ignoreDirs, verbose, includeInternal, internalMarker, outFile) {
-  const found = [];
-  const entries = await fs.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (outFile && path.resolve(fullPath) === path.resolve(outFile)) {
-      if (verbose) {
-        relinka("verbose", `Skipping output file: ${fullPath}`);
-      }
-      continue;
-    }
-    if (entry.isDirectory()) {
-      if (ignoreDirs.includes(entry.name)) {
-        if (verbose) {
-          relinka("verbose", `Skipping ignored directory: ${fullPath}`);
-        }
-        continue;
-      }
-      if (recursive) {
-        const sub = await collectFiles(
-          fullPath,
-          exts,
-          recursive,
-          ignoreDirs,
-          verbose,
-          includeInternal,
-          internalMarker,
-          outFile
-        );
-        found.push(...sub);
-      }
-    } else if (entry.isFile()) {
-      if (!includeInternal && path.basename(fullPath).startsWith(internalMarker)) {
-        if (verbose) {
-          relinka("verbose", `Skipping internal file: ${fullPath}`);
-        }
-        continue;
-      }
-      if (exts.some((ext) => entry.name.toLowerCase().endsWith(ext))) {
-        if (verbose) {
-          relinka("verbose", `Found file: ${fullPath}`);
-        }
-        found.push(fullPath);
-      }
-    }
-  }
-  return found;
-}
-export async function generateAggregatorLines(filePath, inputDir, stripPrefix, useImport, useNamed, usedIdentifiers) {
-  const importPath = buildPathRelative(filePath, inputDir, stripPrefix);
-  if (!useNamed) {
-    if (useImport) {
-      let ident = guessStarImportIdentifier(filePath);
-      if (usedIdentifiers) {
-        let uniqueIdent = ident;
-        let counter = 1;
-        while (usedIdentifiers.has(uniqueIdent)) {
-          uniqueIdent = `${ident}_${counter}`;
-          counter++;
-        }
-        usedIdentifiers.add(uniqueIdent);
-        ident = uniqueIdent;
-      }
-      return [`import * as ${ident} from "${importPath}";`];
-    }
-    return [`export * from "${importPath}";`];
-  }
-  const { typeNames, valueNames } = await getNamedExports(filePath);
-  if (!typeNames.length && !valueNames.length) {
-    return [];
-  }
-  if (useImport) {
-    const lines2 = [];
-    if (typeNames.length > 0) {
-      lines2.push(`import type { ${typeNames.join(", ")} } from "${importPath}";`);
-    }
-    if (valueNames.length > 0) {
-      lines2.push(`import { ${valueNames.join(", ")} } from "${importPath}";`);
-    }
-    return lines2;
-  }
-  const lines = [];
-  if (typeNames.length > 0) {
-    lines.push(`export type { ${typeNames.join(", ")} } from "${importPath}";`);
-  }
-  if (valueNames.length > 0) {
-    lines.push(`export { ${valueNames.join(", ")} } from "${importPath}";`);
-  }
-  return lines;
-}
-export async function getNamedExports(filePath) {
-  try {
-    const code = await fs.readFile(filePath, "utf8");
-    const typeNamesSet = /* @__PURE__ */ new Set();
-    const valueNamesSet = /* @__PURE__ */ new Set();
-    const patterns = [
-      // Regular exports and default exports
-      /^export\s+(?:default\s+)?(?:async\s+)?(function|const|class|let|var|type|interface|enum)\s+([A-Za-z0-9_$]+)/gm,
-      // Named exports and re-exports
-      /^export\s*{([^}]+)}(?:\s+from\s+['"][^'"]+['"])?/gm,
-      // Export assignments
-      /^export\s*=\s*([A-Za-z0-9_$]+)/gm
-    ];
-    for (const pattern of patterns) {
-      let match;
-      while (true) {
-        match = pattern.exec(code);
-        if (!match) break;
-        const matchGroups = match;
-        if (pattern.source.includes("{([^}]+)}") && matchGroups[1]) {
-          const exports = (matchGroups[1] ?? "").split(",").map(
-            (e) => e?.trim()?.split(/\s+as\s+/)?.[0]?.trim() ?? ""
-          );
-          for (const exp of exports) {
-            const name = exp.replace(/^type\s+/, "");
-            if (exp.startsWith("type ")) {
-              typeNamesSet.add(name);
-            } else {
-              valueNamesSet.add(name);
-            }
-          }
-        } else if (pattern.source.includes("=\\s*([A-Za-z0-9_$]+)") && matchGroups[1]) {
-          valueNamesSet.add(matchGroups[1]);
-        } else {
-          const keyword = matchGroups[1];
-          const name = matchGroups[2];
-          if (keyword && name) {
-            if (keyword === "type" || keyword === "interface" || keyword === "enum") {
-              typeNamesSet.add(name);
-            } else {
-              valueNamesSet.add(name);
-            }
-          }
-        }
-      }
-    }
-    return {
-      typeNames: Array.from(typeNamesSet),
-      valueNames: Array.from(valueNamesSet)
-    };
-  } catch (error) {
-    relinka("error", `Error reading file ${filePath}: ${error}`);
-    return { typeNames: [], valueNames: [] };
-  }
-}
-export function guessStarImportIdentifier(filePath) {
-  const base = path.basename(filePath, path.extname(filePath));
-  let identifier = base.replace(/[^a-zA-Z0-9_$]/g, "_");
-  if (/^\d/.test(identifier)) {
-    identifier = `_${identifier}`;
-  }
-  return identifier || "file";
-}
-export function printUsage(isDev) {
-  relinka("verbose", "====================");
-  relinka("verbose", "TOOLS USAGE EXAMPLES");
-  relinka("verbose", "====================");
-  relinka(
-    "log",
-    `${isDev ? "bun dev:agg" : "dler tools"} --tool agg --input <dir> --out <file> [options]`
-  );
-  if (isDev) {
-    relinka(
-      "log",
-      "bun dev:tools agg --input src/libs/sdk/sdk-impl --out src/libs/sdk/sdk-mod.ts --recursive --named --strip src/libs/sdk"
-    );
-  } else {
-    relinka(
-      "log",
-      "dler tools --tool agg --input src/libs --out aggregator.ts --recursive --named"
-    );
-  }
-}

package/bin/libs/sdk/sdk-impl/utils/agg/agg-5.js

@@ -1,17 +0,0 @@
-import fs from "@reliverse/relifso";
-
-/**
- * Checks if the first line of a file contains the disable aggregation comment
- */
-// @ts-expect-error TODO: SOMETHING STRANGE WITH THIS FUNCTION
-// FOR SOME REASON MKDIST DON'T WANT TO REMOVE TS ANNOTATIONS
-// FROM THIS AND ALL FUNCTIONS WHICH LIVE IN THE SAME FILE
-export async function isAggregationDisabled(filePath) {
-  try {
-    const content = await fs.readFile(filePath, "utf-8");
-    const firstLine = content.split("\n")[0]?.trim();
-    return firstLine === "// <dler-disable-agg>";
-  } catch {
-    return false;
-  }
-}

package/bin/libs/sdk/sdk-impl/utils/exec/exec-env.js

@@ -1,34 +0,0 @@
-import { delimiter as pathDelimiter, resolve as resolvePath, dirname } from "node:path";
-const isPathLikePattern = /^path$/i;
-const defaultEnvPathInfo = { key: "PATH", value: "" };
-function getPathFromEnv(env) {
-  for (const key in env) {
-    if (!Object.hasOwn(env, key) || !isPathLikePattern.test(key)) {
-      continue;
-    }
-    const value = env[key];
-    if (!value) return defaultEnvPathInfo;
-    return { key, value };
-  }
-  return defaultEnvPathInfo;
-}
-function addNodeBinToPath(cwd, path) {
-  const parts = path.value.split(pathDelimiter);
-  let currentPath = cwd;
-  let lastPath;
-  do {
-    parts.push(resolvePath(currentPath, "node_modules", ".bin"));
-    lastPath = currentPath;
-    currentPath = dirname(currentPath);
-  } while (currentPath !== lastPath);
-  return { key: path.key, value: parts.join(pathDelimiter) };
-}
-export function computeEnv(cwd, env) {
-  const envWithDefault = {
-    ...process.env,
-    ...env
-  };
-  const envPathInfo = addNodeBinToPath(cwd, getPathFromEnv(envWithDefault));
-  envWithDefault[envPathInfo.key] = envPathInfo.value;
-  return envWithDefault;
-}

package/bin/libs/sdk/sdk-impl/utils/exec/exec-error.d.ts

@@ -1,7 +0,0 @@
-import type { Result, Output } from "./exec-mod.js";
-export declare class NonZeroExitError extends Error {
-    readonly result: Result;
-    readonly output?: Output;
-    get exitCode(): number | undefined;
-    constructor(result: Result, output?: Output);
-}

package/bin/libs/sdk/sdk-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 void 0;
-  }
-  constructor(result, output) {
-    super(`Process exited with non-zero status (${result.exitCode})`);
-    this.result = result;
-    this.output = output;
-  }
-}

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

@@ -1,58 +0,0 @@
-import type { Readable } from "node:stream";
-import { type ChildProcess, type SpawnOptions } from "node:child_process";
-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/libs/sdk/sdk-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 void 0;
-  }
-  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/libs/sdk/sdk-impl/utils/exec/exec-parse.js

@@ -1,71 +0,0 @@
-import path from "node:path";
-import { escapeCommand, escapeArgument } 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 = Object.assign({}, 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/libs/sdk/sdk-impl/utils/exec/exec-resolve.js

@@ -1,39 +0,0 @@
-import { lookpath } from "lookpath";
-import path from "node:path";
-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);
-}