@reliverse/dler 1.7.15 → 1.7.17

package/bin/app/conv/cmd.js

@@ -1,171 +1,193 @@
-import fs from "@reliverse/relifso";
+import * as path from "@reliverse/pathkit";
+import { convertImportsAliasToRelative } from "@reliverse/pathkit";
 import { relinka } from "@reliverse/relinka";
-import { defineArgs, defineCommand } from "@reliverse/rempts";
-import { executeSpell } from "../../libs/sdk/sdk-mod.js";
-export default defineCommand({
-  meta: {
-    name: "conv",
-    version: "1.0.0",
-    description: "Convert files using various SDK converters."
-  },
-  args: defineArgs({
-    type: {
-      type: "string",
-      required: true,
-      description: "Type of conversion to perform (replace, rename, remove-comment, remove-line, remove-file, copy, move, transform, insert)"
-    },
-    input: {
-      type: "string",
-      required: true,
-      description: "Input file or directory path"
-    },
-    output: {
-      type: "string",
-      description: "Output file or directory path (required for copy/move/rename operations)"
-    },
-    pattern: {
-      type: "string",
-      description: "Pattern to match (for replace/remove operations)"
-    },
-    replacement: {
-      type: "string",
-      description: "Replacement text (for replace/insert operations)"
-    },
-    line: {
-      type: "number",
-      description: "Line number (for insert/remove-line operations)"
-    },
-    transform: {
-      type: "string",
-      description: "Transform function name (for transform operation)"
+import { promises as fs } from "node:fs";
+async function validateAliasConfig(alias) {
+  try {
+    const tsconfigPath = path.resolve("tsconfig.json");
+    const tsconfig = JSON.parse(await fs.readFile(tsconfigPath, "utf8"));
+    const paths = tsconfig?.compilerOptions?.paths;
+    if (!paths) {
+      throw new Error("tsconfig.json is missing compilerOptions.paths configuration");
     }
-  }),
-  async run({ args }) {
-    const { type, input, output, pattern, replacement, line, transform } = args;
-    if (!await fs.pathExists(input)) {
-      relinka("error", `\u274C Input path does not exist: ${input}`);
-      return;
+    const aliasPattern = `${alias}/*`;
+    if (!paths[aliasPattern]) {
+      throw new Error(
+        `Alias "${alias}" is not configured in tsconfig.json. Add "${aliasPattern}": ["./src/*"] to compilerOptions.paths`
+      );
     }
-    let spell;
-    switch (type) {
-      case "replace":
-        if (!pattern || !replacement) {
-          relinka("error", "\u274C Pattern and replacement are required for replace operation");
-          return;
-        }
-        spell = {
-          type: "replace-line",
-          params: { hooked: false },
-          value: replacement,
-          fullMatch: pattern
-        };
-        break;
-      case "rename":
-        if (!output) {
-          relinka("error", "\u274C Output path is required for rename operation");
-          return;
-        }
-        spell = {
-          type: "rename-file",
-          params: { hooked: false },
-          fileName: output
-        };
-        break;
-      case "remove-comment":
-        if (!pattern) {
-          relinka("error", "\u274C Pattern is required for remove-comment operation");
-          return;
-        }
-        spell = {
-          type: "remove-comment",
-          params: { hooked: false },
-          fullMatch: pattern
-        };
-        break;
-      case "remove-line":
-        if (!pattern) {
-          relinka("error", "\u274C Pattern is required for remove-line operation");
-          return;
-        }
-        spell = {
-          type: "remove-line",
-          params: { hooked: false },
-          fullMatch: pattern
-        };
-        break;
-      case "remove-file":
-        spell = {
-          type: "remove-file",
-          params: { hooked: false }
-        };
-        break;
-      case "copy":
-        if (!output) {
-          relinka("error", "\u274C Output path is required for copy operation");
-          return;
-        }
-        spell = {
-          type: "copy-file",
-          params: { hooked: false },
-          fileName: output
-        };
-        break;
-      case "move":
-        if (!output) {
-          relinka("error", "\u274C Output path is required for move operation");
-          return;
-        }
-        spell = {
-          type: "move-file",
-          params: { hooked: false },
-          fileName: output
-        };
-        break;
-      case "transform":
-        if (!transform) {
-          relinka("error", "\u274C Transform function name is required for transform operation");
-          return;
-        }
-        spell = {
-          type: "transform-content",
-          params: { hooked: false },
-          value: transform
-        };
-        break;
-      case "insert":
-        if (!line || !replacement) {
-          relinka("error", "\u274C Line number and replacement are required for insert operation");
-          return;
-        }
-        spell = {
-          type: "insert-at",
-          params: { hooked: false },
-          value: replacement,
-          lineNumber: line
-        };
-        break;
-      default:
-        relinka("error", `\u274C Unknown conversion type: ${type}`);
-        return;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to validate alias configuration: ${error.message}`);
     }
-    try {
-      const content = await fs.readFile(input, "utf8");
-      const result = await executeSpell(spell, input, content);
-      if (result.success) {
-        relinka("log", `\u2705 Successfully performed ${type} operation on ${input}`);
-        if (result.changes) {
-          relinka(
-            "log",
-            `\u{1F4DD} Changes:
-Before: ${result.changes.before}
-After: ${result.changes.after}`
-          );
+    throw new Error("Failed to validate alias configuration: Unknown error");
+  }
+}
+export async function resolveCrossLibs(alias = "~", subFolders = ["npm", "jsr"]) {
+  await validateAliasConfig(alias);
+  const distLibsPath = path.resolve("dist-libs");
+  const allModified = [];
+  try {
+    const libs = await fs.readdir(distLibsPath);
+    for (const lib of libs) {
+      for (const subFolder of subFolders) {
+        const libBinDir = path.join("dist-libs", lib, subFolder, "bin");
+        try {
+          await fs.access(libBinDir);
+          const modified = await resolveCrossLibsInternal(libBinDir, alias, subFolders);
+          allModified.push(...modified);
+        } catch {
         }
-      } else {
-        relinka("error", `\u274C Failed to perform ${type} operation: ${result.message}`);
       }
-    } catch (error) {
-      relinka("error", `\u274C Error during conversion: ${error}`);
+    }
+  } catch (error) {
+    throw new Error(`Failed to process dist-libs directory: ${error}`);
+  }
+  return allModified;
+}
+async function resolveCrossLibsInternal(libBinDir, alias = "~", subFolders = ["npm", "jsr"]) {
+  relinka(
+    "verbose",
+    `[resolveCrossLibs] dir=${libBinDir}, alias=${alias}, subs=${subFolders.join("/")}`
+  );
+  if (!libBinDir.startsWith("dist-libs")) {
+    throw new Error(`libBinDir must start with "dist-libs": ${libBinDir}`);
+  }
+  const absBinDir = path.resolve(libBinDir);
+  const [currentLib] = path.relative("dist-libs", libBinDir).split(path.sep);
+  await convertImportsAliasToRelative({
+    targetDir: absBinDir,
+    aliasToReplace: alias,
+    pathExtFilter: "js-ts-none"
+  });
+  async function collect(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const files = await Promise.all(
+      entries.map(
+        (e) => e.isDirectory() ? collect(path.join(dir, e.name)) : e.name.endsWith(".d.ts") || !(e.name.endsWith(".ts") || e.name.endsWith(".js")) ? [] : [path.join(dir, e.name)]
+      )
+    );
+    return files.flat();
+  }
+  const allFiles = await collect(absBinDir);
+  const modified = [];
+  await Promise.all(
+    allFiles.map(async (filePath) => {
+      const original = await fs.readFile(filePath, "utf8");
+      if (!original) {
+        throw new Error(`Failed to read file: ${filePath}`);
+      }
+      if (!currentLib) throw new Error("Current library is undefined");
+      const updated = await transformFile(original, filePath, currentLib, alias, subFolders);
+      if (updated !== original) {
+        await fs.writeFile(filePath, updated, "utf8");
+        modified.push(filePath);
+        relinka("verbose", `[inline]   \u21B3 modified ${path.relative(process.cwd(), filePath)}`);
+      }
+    })
+  );
+  return modified;
+}
+async function transformFile(source, _filePath, currentLib, alias, subFolders) {
+  if (!source) {
+    throw new Error("Source content is undefined");
+  }
+  const ALIAS_RE = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const importRe = new RegExp(
+    String.raw`^\s*` + // leading space
+    String.raw`(` + String.raw`export\s+\{[\s\S]*?\}\s+from\s+` + // export {...} from
+    "|" + String.raw`import\s+[\s\S]*?\s+from\s+` + // import ... from
+    String.raw`)` + String.raw`(['"])` + //   opening quote (group 2)
+    ALIAS_RE + String.raw`/libs/` + String.raw`([^/]+)` + //   libName   (group 3)
+    String.raw`/` + String.raw`([^'"]+)` + //   rest path (group 4)
+    String.raw`\2` + //   same quote
+    String.raw`\s*;?` + //   optional semicolon
+    String.raw`(?:\s*(?://.*|/\*[\s\S]*?\*/))?` + //   optional trailing comment
+    String.raw`\s*$`,
+    "s"
+    // dotAll
+  );
+  const output = [];
+  const lines = source.split(/\r?\n/);
+  let inInlineBlock = false;
+  let buffer = [];
+  const flushBuffer = async () => {
+    if (buffer.length === 0) return;
+    const stmt = buffer.join("\n");
+    relinka("verbose", `  [scan] candidate:
+--------
+${stmt}
+--------`);
+    if (!importRe.test(stmt) || inInlineBlock) {
+      output.push(...buffer);
+      buffer = [];
+      return;
+    }
+    const match = importRe.exec(stmt);
+    if (!match) {
+      output.push(...buffer);
+      buffer = [];
+      return;
+    }
+    const [, _prefix, _quote, libName, restRaw] = match;
+    if (!restRaw || !libName) {
+      throw new Error(`Invalid import statement: ${stmt}`);
+    }
+    const indentMatch = stmt.match(/^\s*/);
+    if (!indentMatch) {
+      throw new Error(`Invalid statement format: ${stmt}`);
+    }
+    const indent = indentMatch[0];
+    const rest = restRaw.replace(/^\/+/, "");
+    if (libName === currentLib) {
+      output.push(stmt);
+      relinka("verbose", `  [skip]      ${libName} (self-import handled by pathkit)`);
+      buffer = [];
+      return;
+    }
+    const targetFile = await resolveTargetFile(libName, rest, subFolders);
+    const embedded = await fs.readFile(targetFile, "utf8");
+    relinka("verbose", `  [inline]    ${libName} \u21A6 ${targetFile}`);
+    const inlinedBlock = `${indent}/* inlined-start ${alias}/libs/${libName}/${rest} */
+` + embedded.split(/\r?\n/).map((l) => indent + l).join("\n") + `
+${indent}/* inlined-end */`;
+    output.push(inlinedBlock);
+    buffer = [];
+  };
+  for (const line of lines) {
+    if (line.includes("/* inlined-start")) inInlineBlock = true;
+    if (line.includes("/* inlined-end")) inInlineBlock = false;
+    if (buffer.length) {
+      buffer.push(line);
+      if (line.trimEnd().endsWith(";")) await flushBuffer();
+      continue;
+    }
+    if (line.includes(`${alias}/libs/`) && /(export|import)\s/.test(line)) {
+      buffer.push(line);
+      if (line.trimEnd().endsWith(";")) await flushBuffer();
+      continue;
+    }
+    output.push(line);
+  }
+  await flushBuffer();
+  return output.join("\n");
+}
+async function resolveTargetFile(lib, rest, subFolders) {
+  const cleaned = rest.replace(/^\/+/, "");
+  for (const sub of subFolders) {
+    const base = path.join("dist-libs", lib, sub, "bin", cleaned);
+    const tsPath = `${base}.ts`;
+    try {
+      await fs.access(tsPath);
+      return tsPath;
+    } catch {
+    }
+    const jsPath = `${base}.js`;
+    try {
+      await fs.access(jsPath);
+      return jsPath;
+    } catch {
     }
   }
-});
+  throw new Error(`Cannot inline ~/libs/${lib}/${rest}: tried [${subFolders.join(", ")}]`);
+}

package/bin/app/copy/cmd.js

@@ -1,7 +1,7 @@
+import { join, dirname, basename } from "@reliverse/pathkit";
 import { relinka } from "@reliverse/relinka";
 import { defineCommand, selectPrompt, inputPrompt } from "@reliverse/rempts";
 import { copyFile, access, mkdir } from "node:fs/promises";
-import { join, dirname, basename } from "node:path";
 import pMap from "p-map";
 import prettyMilliseconds from "pretty-ms";
 import { glob } from "tinyglobby";

package/bin/app/init/init-impl.js

@@ -5,7 +5,7 @@ import { selectPrompt } from "@reliverse/rempts";
 import pMap from "p-map";
 import { FILE_TYPES } from "./init-const.js";
 import { gitignoreTemplate, licenseTemplate, readmeTemplate } from "./init-tmpl.js";
-const DEFAULT_CONFIG = {
+const DEFAULT_CONFIG_INIT = {
   defaultInitBehaviour: "create",
   defaultDestFileExistsBehaviour: "prompt",
   parallelByDefault: false,
@@ -41,7 +41,7 @@ export async function createFileFromScratch(destPath, fileType, contentCreateMod
   }
 }
 export async function initFile(req, userCfg) {
-  const config = { ...DEFAULT_CONFIG, ...userCfg };
+  const config = { ...DEFAULT_CONFIG_INIT, ...userCfg };
   const initBehaviour = req.initBehaviour ?? config.defaultInitBehaviour;
   const existsBehaviour = req.destFileExistsBehaviour ?? config.defaultDestFileExistsBehaviour;
   config.onFileStart?.(req);
@@ -63,7 +63,7 @@ export async function initFile(req, userCfg) {
   return result;
 }
 export async function initFiles(items, options, userCfg) {
-  const config = { ...DEFAULT_CONFIG, ...userCfg };
+  const config = { ...DEFAULT_CONFIG_INIT, ...userCfg };
   const parallel = options?.parallel ?? config.parallelByDefault;
   const concurrency = options?.concurrency ?? config.parallelConcurrency;
   if (parallel) {

package/bin/app/init/init-types.d.ts

@@ -3,7 +3,7 @@ export type FileType = (typeof FILE_TYPES)[number]["type"];
 export type InitBehaviour = (typeof INIT_BEHAVIOURS)[number];
 export type DestFileExistsBehaviour = (typeof DEST_FILE_EXISTS_BEHAVIOURS)[number];
 /** Library-level interface for hooking into the file init process. */
-export type ReinitUserConfig = {
+export interface ReinitUserConfig {
     /** The default approach for copying vs. creating. */
     defaultInitBehaviour?: InitBehaviour;
     /** Default approach if a file already exists. */
@@ -16,26 +16,26 @@ export type ReinitUserConfig = {
     onFileStart?: (req: InitFileRequest) => void;
     /** Called after each file operation. */
     onFileComplete?: (res: InitFileResult) => void;
-};
+}
 /** Data describing a single request to initFile. */
-export type InitFileRequest = {
+export interface InitFileRequest {
     fileType: FileType;
     destDir: string;
     initBehaviour?: InitBehaviour;
     destFileExistsBehaviour?: DestFileExistsBehaviour;
     options?: InitFileOptions;
-};
+}
 /** Extended per-file options. */
-export type InitFileOptions = {
+export interface InitFileOptions {
     destFileName?: string;
     srcCopyMode?: string;
     contentCreateMode?: string;
     fallbackSource?: string;
-};
+}
 /** The result of a single initFile operation. */
-export type InitFileResult = {
+export interface InitFileResult {
     requested: InitFileRequest;
     finalPath?: string;
     status: "created" | "copied" | "skipped" | "error";
     error?: any;
-};
+}

package/bin/app/merge/cmd.d.ts

@@ -1,8 +1,4 @@
 declare const _default: import("@reliverse/rempts").Command<{
-    dev: {
-        type: "boolean";
-        description: string;
-    };
     s: {
         type: "array";
         description: string;
@@ -20,6 +16,14 @@ declare const _default: import("@reliverse/rempts").Command<{
         default: string;
         description: string;
     };
+    "max-file-size": {
+        type: "number";
+        description: string;
+    };
+    "max-merge-size": {
+        type: "number";
+        description: string;
+    };
     stdout: {
         type: "boolean";
         description: string;
@@ -101,27 +105,23 @@ declare const _default: import("@reliverse/rempts").Command<{
         type: "boolean";
         description: string;
     };
-    "as-template": {
-        type: "boolean";
-        description: string;
-    };
-    "custom-template-name": {
-        type: "string";
+    depth: {
+        type: "number";
         description: string;
+        default: number;
     };
-    whitelabel: {
-        type: "string";
+    sourcemap: {
+        type: "boolean";
         description: string;
-        default: string;
     };
-    sourcemap: {
+    verbose: {
         type: "boolean";
         description: string;
     };
-    "update-template": {
-        type: "string";
+    force: {
+        type: "boolean";
         description: string;
-        dependencies: string[];
+        default: true;
     };
 }>;
 export default _default;