@reliverse/dler 1.7.119 → 1.7.121

package/bin/impl/merge/mod.js

@@ -0,0 +1,203 @@
+import path from "@reliverse/pathkit";
+import { glob } from "@reliverse/reglob";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import MagicString, { Bundle } from "magic-string";
+import pMap from "p-map";
+import { isBinaryExt } from "../utils/binary.js";
+import {
+  checkFileSize,
+  checkPermissions,
+  handleCtxError,
+  sanitizeInput,
+  validateContent,
+  validateFileExists,
+  validateFileType,
+  validateMergeOperation,
+  validatePath
+} from "../utils/utils-security.js";
+export const DEFAULT_IGNORES = ["**/.git/**", "**/node_modules/**"];
+export const DEFAULT_SEPARATOR_RAW = "\\n\\n";
+export const normalizeGlobPattern = (pattern) => {
+  const sanitizedPattern = sanitizeInput(pattern);
+  if (!sanitizedPattern.includes("*") && !sanitizedPattern.includes("?") && !sanitizedPattern.endsWith("/")) {
+    return `${sanitizedPattern}/**/*`;
+  }
+  return sanitizedPattern;
+};
+export const parseCSV = (s) => s.split(",").map((t) => sanitizeInput(t.trim())).filter(Boolean);
+export const unescape = (s) => s.replace(/\\n/g, "\n").replace(/\\t/g, "	");
+export const maybePrompt = async (interactive, value, promptFn) => {
+  if (!interactive || value !== void 0) return value;
+  return promptFn();
+};
+export const collectFiles = async (include, extraIgnore, recursive, sortBy, depth) => {
+  try {
+    const normalizedInclude = include.map(normalizeGlobPattern);
+    const files = await glob(normalizedInclude, {
+      ignore: [...DEFAULT_IGNORES, ...extraIgnore.map(sanitizeInput)],
+      absolute: true,
+      onlyFiles: true,
+      deep: recursive ? void 0 : 1
+    });
+    const validFiles = [];
+    let binaryFilesDetected = false;
+    for (const file of files) {
+      await validateFileExists(file, "merge");
+      await checkFileSize(file);
+      await checkPermissions(file, "read");
+      if (await isBinaryExt(file)) {
+        binaryFilesDetected = true;
+        continue;
+      }
+      validFiles.push(file);
+    }
+    if (binaryFilesDetected) {
+      relinka("info", "Binary files were detected and skipped");
+    }
+    let filtered = [...new Set(validFiles)];
+    if (depth > 0) {
+      const fileGroups = /* @__PURE__ */ new Map();
+      for (const file of filtered) {
+        const relPath = path.relative(process.cwd(), file);
+        const parts = relPath.split(path.sep);
+        const groupKey = parts.slice(0, depth).join(path.sep);
+        if (!fileGroups.has(groupKey)) {
+          fileGroups.set(groupKey, []);
+        }
+        const group = fileGroups.get(groupKey);
+        if (group) {
+          group.push(file);
+        }
+      }
+      filtered = Array.from(fileGroups.values()).flat();
+    }
+    if (sortBy === "name") {
+      filtered.sort((a, b) => path.basename(a).localeCompare(path.basename(b)));
+    } else if (sortBy === "path") {
+      filtered.sort();
+    } else if (sortBy === "mtime") {
+      filtered = await pMap(filtered, async (f) => ({ f, mtime: (await fs.stat(f)).mtimeMs }), {
+        concurrency: 8
+      }).then((arr) => arr.sort((a, b) => a.mtime - b.mtime).map((x) => x.f));
+    }
+    return filtered;
+  } catch (error) {
+    handleCtxError(error, "collectFiles");
+    return [];
+  }
+};
+export const writeResult = async (sections, _separator, toFile, toStdout, dryRun, backup, generateSourceMap = false) => {
+  try {
+    const bundle = new Bundle();
+    for (const section of sections) {
+      validateContent(section, "text");
+      bundle.addSource({
+        content: new MagicString(section)
+      });
+    }
+    const content = bundle.toString();
+    const finalContent = `${content}
+`;
+    if (toStdout || !toFile) {
+      process.stdout.write(finalContent);
+      return;
+    }
+    const sanitizedPath = sanitizeInput(toFile);
+    const dir = path.dirname(sanitizedPath);
+    if (dir && dir !== ".") {
+      await fs.ensureDir(dir);
+      await checkPermissions(dir, "write");
+    }
+    if (backup && await fs.pathExists(sanitizedPath)) {
+      const backupPath = `${sanitizedPath}.${Date.now()}.bak`;
+      await checkPermissions(sanitizedPath, "read");
+      await fs.copyFile(sanitizedPath, backupPath);
+    }
+    if (!dryRun) {
+      await checkPermissions(sanitizedPath, "write");
+      validatePath(sanitizedPath, process.cwd());
+      validateFileType("text");
+      await fs.writeFile(sanitizedPath, finalContent, "utf8");
+      if (generateSourceMap) {
+        const map = bundle.generateMap({
+          file: path.basename(sanitizedPath),
+          source: sanitizedPath,
+          includeContent: true,
+          hires: true
+        });
+        const mapPath = `${sanitizedPath}.map`;
+        await fs.writeFile(mapPath, map.toString(), "utf8");
+        const sourceMapRef = `
+//# sourceMappingURL=${path.basename(mapPath)}`;
+        await fs.appendFile(sanitizedPath, sourceMapRef, "utf8");
+      }
+    }
+  } catch (error) {
+    handleCtxError(error, "writeResult");
+  }
+};
+export const writeFilesPreserveStructure = async (files, outDir, preserveStructure, increment, concurrency, dryRun, backup) => {
+  try {
+    if (!files?.length) {
+      throw new Error("No files provided for merge operation");
+    }
+    const cwd = process.cwd();
+    const fileNameCounts = /* @__PURE__ */ new Map();
+    await validateMergeOperation(files);
+    await pMap(
+      files,
+      async (file) => {
+        const sanitizedFile = sanitizeInput(file);
+        const relPath = preserveStructure ? path.relative(cwd, sanitizedFile) : path.basename(sanitizedFile);
+        let destPath = path.join(outDir, relPath);
+        if (increment) {
+          const dir = path.dirname(destPath);
+          const base = path.basename(destPath);
+          let dirMap = fileNameCounts.get(dir);
+          if (!dirMap) {
+            dirMap = /* @__PURE__ */ new Map();
+            fileNameCounts.set(dir, dirMap);
+          }
+          const count = dirMap.get(base) || 0;
+          if (count > 0) {
+            const extMatch = base.match(/(.*)(\.[^./\\]+)$/);
+            let newBase;
+            if (extMatch) {
+              newBase = `${extMatch[1]}-${count + 1}${extMatch[2]}`;
+            } else {
+              newBase = `${base}-${count + 1}`;
+            }
+            destPath = path.join(dir, newBase);
+          }
+          dirMap.set(base, count + 1);
+        }
+        await fs.ensureDir(path.dirname(destPath));
+        if (backup && await fs.pathExists(destPath)) {
+          const backupPath = `${destPath}.${Date.now()}.bak`;
+          await checkPermissions(destPath, "read");
+          await fs.copyFile(destPath, backupPath);
+        }
+        if (!dryRun) {
+          await checkPermissions(destPath, "write");
+          await fs.copyFile(sanitizedFile, destPath);
+        }
+      },
+      { concurrency }
+    );
+  } catch (error) {
+    handleCtxError(error, "writeFilesPreserveStructure");
+  }
+};
+export const processSection = (raw, rel, prefix, pathAbove, injectPath) => {
+  const magic = new MagicString(raw);
+  if (pathAbove) {
+    magic.prepend(`${prefix}${rel}
+`);
+  }
+  if (injectPath) {
+    magic.append(`
+${prefix}${rel}`);
+  }
+  return magic.toString();
+};

package/bin/impl/pack/mod.d.ts

@@ -0,0 +1,43 @@
+export interface FileMetadata {
+    updatedAt?: string;
+    updatedHash?: string;
+}
+export interface TemplatesFileContent {
+    content: FileContent;
+    type: "text" | "json" | "binary";
+    hasError?: boolean;
+    error?: string;
+    jsonComments?: Record<number, string>;
+    binaryHash?: string;
+    metadata?: FileMetadata;
+}
+export type FileContent = string | Record<string, unknown>;
+export interface Template {
+    name: string;
+    description: string;
+    config: {
+        files: Record<string, TemplatesFileContent>;
+    };
+    updatedAt?: string;
+}
+export type ExistingTemplates = Record<string, Template>;
+export declare const WHITELABEL_DEFAULT = "DLER";
+export declare const TEMPLATE_VAR: (name: string, whitelabel: string) => string;
+export declare const TPLS_DIR = "packed";
+export declare const BINARIES_DIR = "binaries";
+/** Escape back-`s, ${ and newlines for safe template literal embedding */
+export declare const escapeTemplateString: (str: string) => string;
+export declare const unescapeTemplateString: (str: string) => string;
+export declare const hashFile: (file: string) => Promise<string>;
+export declare const getFileMetadata: (file: string) => Promise<FileMetadata>;
+/** Recursively walk a directory */
+export declare const walkDir: (dir: string) => Promise<string[]>;
+/** Process a file and return the TemplatesFileContent structure */
+export declare const readFileForTemplate: (absPath: string, relPath: string, binariesOutDir: string) => Promise<TemplatesFileContent>;
+/** Locate the object holding templates in a dynamically-imported module */
+export declare const findTemplatesObject: (mod: Record<string, unknown>) => ExistingTemplates;
+/** Restore one file (text|json|binary) to the filesystem */
+export declare const restoreFile: (outRoot: string, relPath: string, meta: TemplatesFileContent, binsDir: string, force?: boolean) => Promise<void>;
+/** Unpack logic */
+export declare const unpackTemplates: (aggregatorPath: string, outDir: string, force?: boolean) => Promise<void>;
+export declare const writeTypesFile: (outRoot: string, outputName: string) => Promise<void>;

package/bin/impl/pack/mod.js

@@ -0,0 +1,200 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "@reliverse/pathkit";
+import { relinka } from "@reliverse/relinka";
+import { createJiti } from "jiti";
+import stripJsonComments from "strip-json-comments";
+import { isBinaryExt } from "../utils/binary.js";
+export const WHITELABEL_DEFAULT = "DLER";
+export const TEMPLATE_VAR = (name, whitelabel) => `${whitelabel}_TPL_${name.toUpperCase()}`;
+export const TPLS_DIR = "packed";
+export const BINARIES_DIR = "binaries";
+export const escapeTemplateString = (str) => str.replace(/`/g, "\\`").replace(/\\\${/g, "\\u0024{").replace(/\$\{/g, "\\${").replace(/\\\{\{/g, "{{").replace(/\\\}\}/g, "}}").replace(/\r?\n/g, "\\n");
+export const unescapeTemplateString = (str) => str.replace(/\\n/g, "\n").replace(/\\u0024\{/g, "\\${").replace(/\\\\`/g, "`").replace(/\\\\/g, "\\");
+export const hashFile = async (file) => {
+  const buf = await fs.readFile(file);
+  return createHash("sha1").update(buf).digest("hex").slice(0, 10);
+};
+export const getFileMetadata = async (file) => {
+  try {
+    const [stats, hash] = await Promise.all([fs.stat(file), hashFile(file)]);
+    return {
+      updatedAt: stats.mtime.toISOString(),
+      updatedHash: hash
+    };
+  } catch (err) {
+    relinka("warn", `Failed to get metadata for ${file}: ${err.message}`);
+    return {
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedHash: ""
+    };
+  }
+};
+export const walkDir = async (dir) => {
+  let res = [];
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      res = res.concat(await walkDir(full));
+    } else {
+      res.push(full);
+    }
+  }
+  return res;
+};
+export const readFileForTemplate = async (absPath, relPath, binariesOutDir) => {
+  const metadata = await getFileMetadata(absPath);
+  try {
+    if (await isBinaryExt(absPath)) {
+      const hash = metadata.updatedHash;
+      const ext2 = path.extname(absPath);
+      const target = path.join(binariesOutDir, `${hash}${ext2}`);
+      try {
+        await fs.mkdir(binariesOutDir, { recursive: true });
+        await fs.copyFile(absPath, target).catch(async (err) => {
+          if (err.code !== "EEXIST") throw err;
+        });
+      } catch (err) {
+        relinka("error", `Failed copying binary ${relPath}: ${err.message}`);
+        return {
+          content: "",
+          type: "binary",
+          hasError: true,
+          error: err.message,
+          binaryHash: hash,
+          metadata
+        };
+      }
+      return {
+        content: "",
+        type: "binary",
+        binaryHash: hash,
+        metadata
+      };
+    }
+    const raw = await fs.readFile(absPath, "utf8");
+    const ext = path.extname(absPath).toLowerCase();
+    if (ext === ".json") {
+      const comments = {};
+      const lines = raw.split(/\r?\n/);
+      lines.forEach((line, idx) => {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("//") || trimmed.startsWith("/*")) comments[idx + 1] = line;
+      });
+      try {
+        const parsed = JSON.parse(stripJsonComments(raw));
+        return {
+          content: parsed,
+          type: "json",
+          jsonComments: Object.keys(comments).length ? comments : void 0,
+          metadata
+        };
+      } catch (err) {
+        relinka("warn", `Failed to parse JSON file ${relPath}: ${err.message}`);
+        return {
+          content: {},
+          type: "json",
+          hasError: true,
+          error: err.message,
+          jsonComments: Object.keys(comments).length ? comments : void 0,
+          metadata
+        };
+      }
+    }
+    return {
+      content: raw,
+      type: "text",
+      metadata
+    };
+  } catch (err) {
+    relinka("warn", `Failed to read file ${relPath}: ${err.message}`);
+    return {
+      content: "",
+      type: "text",
+      hasError: true,
+      error: err.message,
+      metadata
+    };
+  }
+};
+export const findTemplatesObject = (mod) => {
+  if (mod.DLER_TEMPLATES && typeof mod.DLER_TEMPLATES === "object") {
+    return mod.DLER_TEMPLATES;
+  }
+  if (mod.default && typeof mod.default === "object") {
+    return mod.default;
+  }
+  for (const v of Object.values(mod)) {
+    if (v && typeof v === "object" && Object.values(v).every((t) => t && typeof t === "object" && "config" in t)) {
+      return v;
+    }
+  }
+  return {};
+};
+export const restoreFile = async (outRoot, relPath, meta, binsDir, force = false) => {
+  const dest = path.join(outRoot, relPath);
+  await fs.mkdir(path.dirname(dest), { recursive: true });
+  try {
+    if (!force) {
+      await fs.access(dest);
+      relinka("verbose", `Skipping existing file (use --force to overwrite): ${relPath}`);
+      return;
+    }
+  } catch {
+  }
+  if (meta.type === "binary") {
+    const ext = path.extname(relPath);
+    const src = path.join(binsDir, `${meta.binaryHash}${ext}`);
+    try {
+      await fs.copyFile(src, dest);
+    } catch (err) {
+      relinka("error", `Missing binary ${src} for ${relPath}: ${err.message}`);
+    }
+  } else if (meta.type === "json") {
+    const jsonStr = JSON.stringify(meta.content, null, 2);
+    await fs.writeFile(dest, jsonStr, "utf8");
+  } else {
+    await fs.writeFile(dest, meta.content, "utf8");
+  }
+  if (meta.metadata?.updatedAt) {
+    const ts = new Date(meta.metadata.updatedAt);
+    await fs.utimes(dest, ts, ts);
+  }
+};
+export const unpackTemplates = async (aggregatorPath, outDir, force = false) => {
+  const jiti = createJiti(process.cwd());
+  let mod;
+  try {
+    mod = await jiti.import(aggregatorPath);
+  } catch (err) {
+    throw new Error(`Failed to import aggregator file: ${err.message}`);
+  }
+  const templatesObj = findTemplatesObject(mod);
+  if (!Object.keys(templatesObj).length) {
+    throw new Error("No templates found in aggregator file.");
+  }
+  const binsDir = path.join(path.dirname(aggregatorPath), TPLS_DIR, BINARIES_DIR);
+  let unpackedFiles = 0;
+  for (const [tplName, tpl] of Object.entries(templatesObj)) {
+    relinka("info", `Unpacking template: ${tplName}`);
+    for (const [relPath, meta] of Object.entries(tpl.config.files)) {
+      try {
+        await restoreFile(outDir, relPath, meta, binsDir, force);
+        unpackedFiles++;
+      } catch (err) {
+        relinka("error", `Failed restoring ${relPath}: ${err.message}`);
+      }
+    }
+  }
+  relinka("success", `Unpacked ${unpackedFiles} files into ${outDir}`);
+};
+export const writeTypesFile = async (outRoot, outputName) => {
+  const typesFile = path.join(outRoot, `${outputName}-types.ts`);
+  const code = `// Auto-generated type declarations for templates.
+export interface FileMetadata { updatedAt?: string; updatedHash?: string; }
+export interface TemplatesFileContent { content: string | Record<string, unknown>; type: 'text' | 'json' | 'binary'; hasError?: boolean; error?: string; jsonComments?: Record<number, string>; binaryHash?: string; metadata?: FileMetadata; }
+export interface Template { name: string; description: string; config: { files: Record<string, TemplatesFileContent> }; updatedAt?: string; }
+`;
+  await fs.writeFile(typesFile, code, "utf8");
+};

package/bin/impl/remdn/mod.d.ts

@@ -0,0 +1,45 @@
+export interface DirOptions {
+    /** File extensions to include (e.g. ".ts"). If omitted, include all. */
+    includeExt?: string[];
+    /** File extensions to exclude. */
+    excludeExt?: string[];
+}
+export type DirConfig = Record<string, DirOptions>;
+export type ExtMap = Record<string, [string, string, string]>;
+export interface ConfigRemdn {
+    title?: string;
+    output?: string;
+    dirs: DirConfig;
+    "ext-map"?: ExtMap;
+}
+/** Tree representation: folder → set of filenames (no paths). */
+export interface FileTree {
+    folders: Map<string, Set<string>>;
+}
+export declare const DEFAULT_CONFIG: ConfigRemdn;
+export declare const DEFAULT_CONFIG_PATH = "remdn.ts";
+export declare const resolvePath: (path: string) => string;
+export declare const validateConfigPath: (filePath: string) => void;
+export declare const validateOutputPath: (filePath: string) => void;
+export declare const evaluateTsConfig: (filePath: string) => Promise<ConfigRemdn>;
+export declare const expandDistLibs: (dirs: DirConfig) => Promise<DirConfig>;
+export declare const readConfig: (path?: string) => Promise<ConfigRemdn>;
+export declare const validateFilters: ({ includeExt, excludeExt }: DirOptions) => void;
+export declare const shouldInclude: (file: string, opts: DirOptions) => boolean;
+export declare const getCanonicalFilename: (filename: string, extMap?: ExtMap, dirPath?: string) => string;
+export declare const getExpectedFilenames: (canonicalFilename: string, dirPath: string, extMap?: ExtMap) => string[];
+export declare const scanDir: (base: string, opts: DirOptions) => Promise<FileTree>;
+export declare const normalizePath: (path: string) => string;
+export declare const generateAnchor: (path: string) => string;
+export declare const buildTableHeader: (paths: string[]) => string[];
+export declare function mapDistLibsFolderToLibs(folder: string, colPath: string, allPaths: string[]): string;
+export declare const isDistLibsPath: (p: string) => boolean;
+export declare const buildTableRow: (canonicalFilename: string, paths: string[], trees: FileTree[], folder: string, extMap?: ExtMap) => string;
+export declare const buildMarkdown: (title: string, paths: string[], trees: FileTree[], extMap?: ExtMap) => string;
+export declare const findMissingFiles: (mainTree: FileTree, otherTrees: FileTree[], paths: string[], extMap?: ExtMap) => string[];
+export declare const ensureOutputPath: (path: string) => string;
+export declare const ensureConfigPath: (path: string) => Promise<string>;
+export declare const buildHtml: (title: string, paths: string[], trees: FileTree[], extMap?: ExtMap) => string;
+export declare const getFormatFromExtension: (filePath: string) => "markdown" | "html";
+export declare const createDefaultConfig: (path: string) => Promise<void>;
+export declare function scanDirectories(config?: ConfigRemdn, configPath?: string, outputPath?: string): Promise<void>;