@reliverse/dler 1.7.15 → 1.7.17

package/bin/app/pack/cmd.js

@@ -0,0 +1,313 @@
+import path from "@reliverse/pathkit";
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { createJiti } from "jiti";
+import { createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import {
+  WHITELABEL_DEFAULT,
+  TEMPLATE_VAR,
+  TPLS_DIR,
+  BINARIES_DIR
+} from "../../libs/sdk/sdk-impl/utils/pack-unpack/pu-constants.js";
+import {
+  escapeTemplateString,
+  readFileForTemplate,
+  walkDir
+} from "../../libs/sdk/sdk-impl/utils/pack-unpack/pu-file-utils.js";
+const jiti = createJiti(import.meta.url);
+const hashFile = async (file) => {
+  const buff = await fs.readFile(file);
+  return createHash("sha1").update(buff).digest("hex").slice(0, 10);
+};
+const getFileMetadata = async (file) => {
+  const stats = await fs.stat(file);
+  const hash = await hashFile(file);
+  return {
+    updatedAt: stats.mtime.toISOString(),
+    updatedHash: hash
+  };
+};
+export default defineCommand({
+  meta: {
+    name: "pack",
+    version: "1.1.0",
+    description: "Packs a directory of templates into TS modules"
+  },
+  args: defineArgs({
+    dir: { type: "positional", required: true, description: "Directory to process" },
+    output: { type: "string", default: "my-templates", description: "Output dir" },
+    whitelabel: { type: "string", default: WHITELABEL_DEFAULT, description: "Rename DLER" },
+    cdn: {
+      type: "string",
+      description: "Remote CDN for binary assets upload (not yet implemented)"
+    },
+    force: { type: "boolean", default: false, description: "Force overwrite existing files" },
+    update: {
+      type: "boolean",
+      default: true,
+      description: "Update existing templates and add new ones if needed (default: true)"
+    },
+    /**
+     * - Without --files: All files are checked and updated if they're newer or have different content
+     * - With --files: Only specified files are checked and updated if they're newer or have different content
+     */
+    files: {
+      type: "string",
+      description: "Comma-separated list of specific files to update (relative to template dir)"
+    },
+    lastUpdate: {
+      type: "string",
+      description: "Override lastUpdate timestamp (format: 2025-06-06T14:33:09.240Z)"
+    }
+  }),
+  async run({ args }) {
+    if (args.cdn) throw new Error("Remote CDN support is not implemented yet.");
+    const dirToProcess = path.resolve(args.dir);
+    const outDir = path.resolve(args.output);
+    const outDirName = path.basename(outDir);
+    const typesFile = `${outDirName}-types.ts`;
+    const modFile = `${outDirName}-mod.ts`;
+    const filesToUpdate = args.files ? new Set(args.files.split(",").map((f) => f.trim())) : null;
+    let existingTemplates = {};
+    try {
+      const files = await fs.readdir(outDir);
+      if (files.length > 0) {
+        if (!args.force && !args.update) {
+          relinka("error", `Error: Output directory '${outDir}' already exists and is not empty.`);
+          relinka(
+            "error",
+            "Use --force to overwrite all files or --update to update existing templates."
+          );
+          process.exit(1);
+        }
+        if (args.update) {
+          try {
+            const modPath = path.join(outDir, modFile);
+            const mod2 = await jiti.import(modPath);
+            existingTemplates = mod2?.DLER_TEMPLATES || mod2?.default || {};
+          } catch (loadError) {
+            relinka(
+              "warn",
+              `Warning: Could not load existing templates from ${modFile}. Will create new ones.`
+            );
+            relinka("log", `Error details: ${loadError.message}`);
+          }
+        }
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    await fs.mkdir(path.join(outDir, TPLS_DIR), { recursive: true });
+    const templateDirs = (await fs.readdir(dirToProcess, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
+    try {
+      await fs.access(path.join(outDir, typesFile));
+    } catch {
+      const typesContent = `export type FileContent = string | Record<string, unknown>;
+export type FileType = "text" | "json" | "binary";
+export type FileMetadata = {
+  updatedAt?: string;
+  updatedHash?: string;
+};
+export type TemplatesFileContent = {
+  content: FileContent;
+  type: FileType;
+  hasError?: boolean;
+  jsonComments?: Record<number, string>;
+  binaryHash?: string;
+  metadata?: FileMetadata;
+};
+export type TemplateConfig = {
+  files: Record<string, TemplatesFileContent>;
+};
+export type Template = {
+  name: string;
+  description: string;
+  config: TemplateConfig;
+  updatedAt?: string;
+};
+export type Templates = Record<string, Template>;
+`;
+      await fs.writeFile(path.join(outDir, typesFile), typesContent);
+    }
+    const aggregatedImports = [];
+    const aggregatedEntries = [];
+    const mapEntries = [];
+    for (const tplName of templateDirs) {
+      const absTplDir = path.join(dirToProcess, tplName);
+      const allFiles = await walkDir(absTplDir);
+      const filesRecord = {};
+      const existingTemplate = args.update ? existingTemplates[tplName] : null;
+      const existingFiles = existingTemplate?.config?.files || {};
+      for (const absFile of allFiles) {
+        const rel = path.relative(dirToProcess, absFile).replace(/\\/g, "/");
+        if (filesToUpdate && !filesToUpdate.has(rel)) {
+          if (existingFiles[rel]) {
+            filesRecord[rel] = existingFiles[rel];
+          }
+          continue;
+        }
+        const fileMetadata = await getFileMetadata(absFile);
+        const existingFile = existingFiles[rel];
+        const existingMetadata = existingFile?.metadata;
+        if (existingMetadata && (existingMetadata.updatedHash === fileMetadata.updatedHash || fileMetadata.updatedAt <= existingMetadata.updatedAt)) {
+          filesRecord[rel] = existingFile;
+          continue;
+        }
+        const meta = await readFileForTemplate(absFile);
+        if (meta.type === "binary") {
+          const hash = await hashFile(absFile);
+          const ext = path.extname(absFile);
+          const binariesDir = path.join(outDir, TPLS_DIR, BINARIES_DIR);
+          const target = path.join(binariesDir, `${hash}${ext}`);
+          await fs.mkdir(binariesDir, { recursive: true });
+          try {
+            await fs.access(target);
+          } catch {
+            await fs.copyFile(absFile, target);
+          }
+          filesRecord[rel] = {
+            type: "binary",
+            content: "",
+            binaryHash: hash,
+            metadata: fileMetadata
+          };
+          continue;
+        }
+        if (meta.type === "json") {
+          if (rel.endsWith("package.json")) {
+            meta.content.__satisfies = "PackageJson";
+          }
+          if (rel.endsWith("tsconfig.json")) {
+            meta.content.__satisfies = "TSConfig";
+          }
+        }
+        filesRecord[rel] = {
+          ...meta,
+          metadata: fileMetadata
+        };
+      }
+      const varName = TEMPLATE_VAR(tplName, args.whitelabel);
+      const code = [];
+      const hasPackageJson = Object.values(filesRecord).some(
+        (f) => f.type === "json" && f.content && typeof f.content === "object" && "name" in f.content
+      );
+      const hasTSConfig = Object.values(filesRecord).some(
+        (f) => f.type === "json" && f.content && typeof f.content === "object" && "compilerOptions" in f.content
+      );
+      if (hasPackageJson || hasTSConfig) {
+        const t = [];
+        if (hasPackageJson) t.push("PackageJson");
+        if (hasTSConfig) t.push("TSConfig");
+        code.push(`import type { ${t.join(", ")} } from "pkg-types";`);
+        code.push("", `import type { Template } from "../${typesFile}";`);
+      } else {
+        code.push(`import type { Template } from "../${typesFile}";`);
+      }
+      code.push("");
+      code.push(`export const ${varName}: Template = {`);
+      code.push(`  name: "${tplName}",`);
+      code.push(`  description: "Template generated from ${allFiles.length} files",`);
+      code.push(`  updatedAt: "${(/* @__PURE__ */ new Date()).toISOString()}",`);
+      code.push("  config: {");
+      code.push("    files: {");
+      const fileEntries = Object.entries(filesRecord);
+      fileEntries.forEach(([rel, meta], index) => {
+        const isLast = index === fileEntries.length - 1;
+        code.push(`      "${rel}": {`);
+        if (meta.jsonComments)
+          code.push(`        jsonComments: ${JSON.stringify(meta.jsonComments, null, 2)},`);
+        if (meta.metadata) {
+          const metadataStr = JSON.stringify(meta.metadata, null, 2).replace(/^/gm, "        ").replace(/^ {7} {/m, " {").replace(/^ {8}}/m, "        }").replace(/"([a-zA-Z0-9_]+)":/g, "$1:").replace(/}$/m, "},");
+          code.push(`        metadata:${metadataStr}`);
+        }
+        if (meta.type === "binary") {
+          code.push(`        content: "",`);
+          code.push(`        type: "binary",`);
+          code.push(`        binaryHash: "${meta.binaryHash}",`);
+        } else if (meta.type === "text") {
+          code.push(`        content: \`${escapeTemplateString(meta.content)}\`,`);
+          code.push('        type: "text",');
+        } else {
+          const clone = { ...meta.content };
+          let sat = "";
+          if (rel.endsWith("package.json")) {
+            sat = " satisfies PackageJson";
+          } else if (rel.endsWith("tsconfig.json")) {
+            sat = " satisfies TSConfig";
+          }
+          const jsonStr = JSON.stringify(
+            clone,
+            (key, value) => {
+              if (typeof key === "string" && /^[a-zA-Z0-9_]+$/.test(key)) {
+                return value;
+              }
+              return value;
+            },
+            2
+          ).split("\n").map((line, i) => {
+            if (i === 0) return line;
+            return "        " + line.replace(/"([a-zA-Z0-9_]+)":/g, "$1:");
+          }).join("\n").replace(/}$/m, "},");
+          code.push(`        content: ${jsonStr}${sat},`);
+          code.push('        type: "json",');
+        }
+        if (meta.hasError) code.push("        hasError: true,");
+        code.push(`      }${isLast ? "," : ","}`);
+      });
+      code.push("    },");
+      code.push("  },");
+      code.push("};");
+      code.push("");
+      const templatePath = path.join(outDir, TPLS_DIR, `${tplName}.ts`);
+      if (args.update && existingTemplates[tplName]) {
+        try {
+          const existingContent = await fs.readFile(templatePath, "utf8");
+          const newContent = code.join("\n");
+          if (existingContent !== newContent) {
+            if (filesToUpdate) {
+              relinka("log", `Updating specific files in template: ${tplName}`);
+            } else {
+              relinka("log", `Updating template: ${tplName}`);
+            }
+          }
+        } catch (error) {
+          if (error.code !== "ENOENT") {
+            throw error;
+          }
+          relinka("log", `Creating new template: ${tplName}`);
+        }
+      } else if (!args.update) {
+        relinka("log", `Creating template: ${tplName}`);
+      }
+      await fs.writeFile(templatePath, code.join("\n"));
+      aggregatedImports.push(`import { ${varName} } from "./${TPLS_DIR}/${tplName}";`);
+      aggregatedEntries.push(`  ${tplName}: ${varName},`);
+      mapEntries.push(`  ${varName}: "${tplName}",`);
+    }
+    const WL = args.whitelabel.toUpperCase();
+    const mod = [
+      ...aggregatedImports,
+      "",
+      `export const ${WL}_TEMPLATES = {`,
+      ...aggregatedEntries,
+      "} as const;",
+      "",
+      `export type ${WL}_TEMPLATE_NAMES = keyof typeof ${WL}_TEMPLATES;`,
+      "",
+      `export const dlerTemplatesMap: Record<string, ${WL}_TEMPLATE_NAMES> = {`,
+      ...mapEntries,
+      "};"
+    ];
+    await fs.writeFile(path.join(outDir, modFile), mod.join("\n") + "\n");
+    const templatePaths = templateDirs.map(
+      (tpl) => path.relative(process.cwd(), path.join(outDir, TPLS_DIR, `${tpl}.ts`))
+    );
+    relinka("log", `Packed ${templateDirs.length} templates into ${modFile}:`);
+    for (const p of templatePaths) {
+      relinka("log", `- ${p}`);
+    }
+  }
+});

package/bin/app/pub/cmd.js

@@ -1,7 +1,7 @@
 import { defineArgs, defineCommand } from "@reliverse/rempts";
-import { dlerPub } from "../build/impl.js";
-import { ensureDlerConfig } from "../../libs/sdk/sdk-impl/cfg/init.js";
-import { loadConfig } from "../../libs/sdk/sdk-impl/cfg/load.js";
+import { dlerPub } from "./impl.js";
+import { ensureDlerConfig } from "../../libs/sdk/sdk-impl/config/init.js";
+import { getConfigDler } from "../../libs/sdk/sdk-impl/config/load.js";
 import { removeDistFolders } from "../../libs/sdk/sdk-mod.js";
 export default defineCommand({
   meta: {
@@ -16,7 +16,7 @@ export default defineCommand({
   }),
   async run({ args }) {
     await ensureDlerConfig(args.dev);
-    const config = await loadConfig();
+    const config = await getConfigDler();
     await removeDistFolders(
       config.distNpmDirName,
       config.distJsrDirName,

package/bin/app/pub/impl.d.ts

@@ -0,0 +1,7 @@
+import type { DlerConfig } from "../../libs/sdk/sdk-impl/config/types.js";
+/**
+ * Main entry point for the dler build and publish process.
+ * Handles building and publishing for both main project and libraries.
+ * @see `src/app/build/impl.ts` for build main function implementation.
+ */
+export declare function dlerPub(isDev: boolean, config?: DlerConfig): Promise<void>;

package/bin/app/pub/impl.js

@@ -0,0 +1,97 @@
+import { bumpHandler, isBumpDisabled, setBumpDisabledValueTo } from "@reliverse/bleump";
+import path, { convertImportsAliasToRelative } from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { getConfigDler } from "../../libs/sdk/sdk-impl/config/load.js";
+import { processLibraryFlow } from "../../libs/sdk/sdk-impl/library-flow.js";
+import { processRegularFlow } from "../../libs/sdk/sdk-impl/regular-flow.js";
+import { applyMagicSpells } from "../../libs/sdk/sdk-impl/spell/applyMagicSpells.js";
+import { finalizeBuildPub } from "../../libs/sdk/sdk-impl/utils/finalize.js";
+import { resolveAllCrossLibs } from "../../libs/sdk/sdk-impl/utils/resolve-cross-libs.js";
+import { removeDistFolders } from "../../libs/sdk/sdk-impl/utils/utils-clean.js";
+import { PROJECT_ROOT } from "../../libs/sdk/sdk-impl/utils/utils-consts.js";
+import { handleDlerError } from "../../libs/sdk/sdk-impl/utils/utils-error-cwd.js";
+import { createPerfTimer } from "../../libs/sdk/sdk-impl/utils/utils-perf.js";
+export async function dlerPub(isDev, config) {
+  const timer = createPerfTimer();
+  let effectiveConfig = config;
+  try {
+    if (!effectiveConfig) {
+      effectiveConfig = await getConfigDler();
+    }
+    if (effectiveConfig.logsFreshFile) {
+      await fs.remove(path.join(PROJECT_ROOT, effectiveConfig.logsFileName));
+    }
+    await removeDistFolders(
+      effectiveConfig.distNpmDirName,
+      effectiveConfig.distJsrDirName,
+      effectiveConfig.libsDirDist,
+      effectiveConfig.libsList
+    );
+    const bumpIsDisabled = await isBumpDisabled();
+    if (!bumpIsDisabled && !effectiveConfig.commonPubPause) {
+      try {
+        await bumpHandler(
+          effectiveConfig.bumpMode,
+          false,
+          effectiveConfig.bumpFilter,
+          effectiveConfig.bumpSet
+        );
+        await setBumpDisabledValueTo(true);
+      } catch {
+        throw new Error("[.config/dler.ts] Failed to set bumpDisable to true");
+      }
+    }
+    await processRegularFlow(timer, isDev, effectiveConfig);
+    await processLibraryFlow(timer, isDev, effectiveConfig);
+    await resolveAllCrossLibs();
+    await applyMagicSpells(["dist-jsr", "dist-npm", "dist-libs"]);
+    relinka("log", "[processDistDirectory] dist-npm");
+    await processDistDirectory("dist-npm", "~");
+    relinka("log", "[processDistDirectory] dist-jsr");
+    await processDistDirectory("dist-jsr", "~");
+    await finalizeBuildPub(
+      timer,
+      effectiveConfig.commonPubPause,
+      effectiveConfig.libsList,
+      effectiveConfig.distNpmDirName,
+      effectiveConfig.distJsrDirName,
+      effectiveConfig.libsDirDist
+    );
+  } catch (error) {
+    handleDlerError(error);
+  }
+}
+async function directoryExists(dirPath) {
+  try {
+    const stat = await fs.stat(dirPath);
+    return stat.isDirectory();
+  } catch (error) {
+    if (error instanceof Error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function processDistDirectory(dir, alias) {
+  const modifiedFiles = [];
+  try {
+    const binDir = path.join(dir, "bin");
+    const binDirExists = await directoryExists(binDir);
+    if (binDirExists) {
+      await convertImportsAliasToRelative({
+        targetDir: binDir,
+        aliasToReplace: alias,
+        pathExtFilter: "js-ts-none"
+        // displayLogsOnlyFor: [
+        //   "dist-npm/bin/libs/cfg/cfg-mod.js",
+        //   "dist-jsr/bin/libs/cfg/cfg-mod.ts",
+        // ],
+      });
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw error;
+  }
+  return modifiedFiles;
+}

package/bin/app/rename/cmd.js

@@ -1,9 +1,9 @@
+import { join, dirname, basename, extname } from "@reliverse/pathkit";
 import { relinka } from "@reliverse/relinka";
 import { defineCommand } from "@reliverse/rempts";
 import { existsSync } from "node:fs";
 import { readFileSync } from "node:fs";
 import { rename, access, readdir } from "node:fs/promises";
-import { join, dirname, basename, extname } from "node:path";
 async function fileExists(path) {
   try {
     await access(path);

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

@@ -1,16 +1,25 @@
 declare const _default: import("@reliverse/rempts").Command<{
-    spells: {
-        type: "string";
+    targets: {
+        type: "array";
         description: string;
-        default: string;
+        required: true;
     };
-    files: {
+    lib: {
         type: "string";
         description: string;
     };
-    dryRun: {
+    concurrency: {
+        type: "number";
+        description: string;
+    };
+    batchSize: {
+        type: "number";
+        description: string;
+    };
+    stopOnError: {
         type: "boolean";
         description: string;
+        default: true;
     };
 }>;
 export default _default;

package/bin/app/spell/cmd.js

@@ -1,47 +1,47 @@
 import { defineArgs, defineCommand } from "@reliverse/rempts";
-import { spells } from "../../libs/sdk/sdk-impl/spell/spell-mod.js";
+import { applyMagicSpells } from "../../libs/sdk/sdk-impl/spell/applyMagicSpells.js";
+import { formatError } from "../../libs/sdk/sdk-impl/utils/utils-error-cwd.js";
 export default defineCommand({
-  meta: {
-    name: "spells",
-    version: "1.0.0",
-    description: "Execute magic spells in your codebase"
-  },
   args: defineArgs({
-    spells: {
-      type: "string",
-      description: "Comma-separated list of spells to execute (or 'all')",
-      default: "all"
+    targets: {
+      type: "array",
+      description: "Distribution types to process",
+      required: true
     },
-    files: {
+    lib: {
       type: "string",
-      description: "Comma-separated list of files to process (or all if not specified)"
+      description: "Library to process (e.g. cfg, sdk, etc) (for usage with `dist-libs`)"
+    },
+    concurrency: {
+      type: "number",
+      description: "Number of files to process in parallel"
     },
-    dryRun: {
+    batchSize: {
+      type: "number",
+      description: "Number of files to process in each batch"
+    },
+    stopOnError: {
       type: "boolean",
-      description: "Preview changes without applying them"
+      description: "Stop processing on first error",
+      default: true
     }
   }),
   async run({ args }) {
-    const requestedSpells = args.spells ? args.spells.split(",") : ["all"];
-    const files = args.files ? args.files.split(",") : [];
-    console.log(`Triggering spells: ${requestedSpells.join(", ")}`);
-    if (files.length) {
-      console.log(`On files: ${files.join(", ")}`);
-    } else {
-      console.log("On all files");
-    }
-    if (args.dryRun) {
-      console.log("DRY RUN - No changes will be applied");
+    const { targets, lib, concurrency, batchSize, stopOnError } = args;
+    if (lib && !targets?.includes("dist-libs")) {
+      throw new Error("The 'lib' parameter can only be used with 'dist-libs' target");
     }
-    const results = await spells({
-      spells: requestedSpells,
-      files,
-      dryRun: args.dryRun
-    });
-    console.log("\nResults:");
-    for (const result of results) {
-      const status = result.success ? "\u2713" : "\u2717";
-      console.log(`${status} ${result.file}: ${result.spell.type} - ${result.message}`);
+    try {
+      const finalTargets = targets?.map(
+        (target) => target === "dist-libs" && lib ? `${target}/${lib}` : target
+      ) ?? [];
+      await applyMagicSpells(finalTargets, {
+        concurrency,
+        batchSize,
+        stopOnError
+      });
+    } catch (error) {
+      throw new Error(`\u274C Processing failed: ${formatError(error)}`);
     }
   }
 });

package/bin/app/{mock → unpack}/cmd.d.ts

@@ -1,18 +1,19 @@
 declare const _default: import("@reliverse/rempts").Command<{
-    template: {
-        type: "string";
+    templatesDir: {
+        type: "positional";
+        required: true;
         description: string;
-        default: string;
     };
-    "template-file": {
+    output: {
         type: "string";
+        default: string;
         description: string;
     };
-    "template-consts": {
+    cdn: {
         type: "string";
         description: string;
     };
-    cleanup: {
+    deleteTemplates: {
         type: "boolean";
         description: string;
         default: false;
@@ -22,20 +23,15 @@ declare const _default: import("@reliverse/rempts").Command<{
         description: string;
         default: false;
     };
-    verbose: {
+    force: {
         type: "boolean";
         description: string;
         default: false;
     };
-    whitelabel: {
-        type: "string";
-        description: string;
-        default: string;
-    };
-    force: {
+    cleanup: {
         type: "boolean";
         description: string;
-        default: true;
+        default: false;
     };
 }>;
 export default _default;