@reliverse/dler 1.7.50 → 1.7.52

package/README.md

@@ -17,7 +17,7 @@
 ### ⚡ developer experience
 
 - **performance optimized** for speed with modern build pipelines and caching
-- **18 built-in commands** — comprehensive [dler commands](#dler-commands) for every workflow
+- **16 built-in commands** — comprehensive [dler commands](#dler-commands) for every workflow
 - **path resolution magic** converts typescript aliases to relative imports automatically
 - **highly configurable** via dedicated configuration files with sensible defaults
 - **dual interface** — cli for everyday use, sdk for advanced programmatic control
@@ -148,7 +148,7 @@ bun dev # bun src/cli.ts --dev
 
 ## dler commands
 
-dler ships with a flexible command system (prev. plugins) and **18 built-in commands** (from [reliverse addons](https://reliverse.org/addons) collection).
+dler ships with a flexible command system (prev. plugins) and **16 built-in commands** (from [reliverse addons](https://reliverse.org/addons) collection).
 
 feel free to create your own commands. commands can be implemented as built-in directly in `src/app/<command>/impl/*` and then imported from `src/app/<command>/cmd.ts`; or implemented in your own library and then imported from `src/app/<command>/cmd.ts`.
 
@@ -156,7 +156,7 @@ if you run just `dler` — it will display a list of commands which you can laun
 
 ## **available commands**
 
-[build](#1-build) — [pub](#2-pub) — [agg](#3-agg) — [check](#4-check) — [conv](#5-conv) — [copy](#6-copy) — [init](#7-init) — [inject](#8-inject) — [libs](#9-libs) — [merge](#10-merge) — [migrate](#11-migrate) — [rempts](#12-rempts) — [rename](#13-rename) — [spell](#14-magic) — [split](#15-split) — [pack](#16-pack) — [unpack](#17-unpack)
+[build](#1-build) — [pub](#2-pub) — [agg](#3-agg) — [check](#4-check) — [conv](#5-conv) — [copy](#6-copy) — [init](#7-init) — [inject](#8-inject) — [libs](#9-libs) — [merge](#10-merge) — [migrate](#11-migrate) — [rempts](#12-rempts) — [rename](#13-rename) — [spell](#14-magic) — [split](#15-split) — [pack](#16-pack)
 
 ### 1. `build`
 
@@ -798,7 +798,7 @@ output/
 └── mod.ts
 ```
 
-### 17. `unpack`
+**--unpack**:
 
 creates file structure from packed templates. This command is the counterpart to `pack` and is used to extract and restore template files from a packed template package.
 
@@ -818,16 +818,16 @@ creates file structure from packed templates. This command is the counterpart to
 
 ```bash
 # Basic usage
-dler unpack ./dist-templates --output ./my-project
+dler pack ./dist-templates --output ./my-project --unpack
 
 # With custom output directory
-dler unpack ./dist-templates --output ./custom-location
+dler pack ./dist-templates --output ./custom-location --unpack
 
 # Preview changes without applying
-dler unpack ./dist-templates --output ./my-project --dry-run
+dler pack ./dist-templates --output ./my-project --dry-run --unpack
 
 # Clean up existing template files before unpacking
-dler unpack ./dist-templates --output ./my-project --cleanup
+dler pack ./dist-templates --output ./my-project --cleanup --unpack
 ```
 
 **arguments:**

package/bin/app/build/ppb-utils.js

@@ -35,7 +35,7 @@ async function isCommandInPackageJson(command) {
     const packageName = COMMAND_TO_PACKAGE[command];
     if (!packageName) return false;
     return packageName in (packageJson.dependencies || {}) || packageName in (packageJson.devDependencies || {});
-  } catch (error) {
+  } catch (_error) {
     return false;
   }
 }

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

@@ -1,5 +1,28 @@
+interface FileMetadata {
+    updatedAt?: string;
+    updatedHash?: string;
+}
+interface TemplatesFileContent {
+    content: FileContent;
+    type: "text" | "json" | "binary";
+    hasError?: boolean;
+    error?: string;
+    jsonComments?: Record<number, string>;
+    binaryHash?: string;
+    metadata?: FileMetadata;
+}
+type FileContent = string | Record<string, unknown>;
+/** 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>;
 declare const _default: import("@reliverse/rempts").Command<{
-    dir: {
+    input: {
         type: "positional";
         required: true;
         description: string;
@@ -11,7 +34,7 @@ declare const _default: import("@reliverse/rempts").Command<{
     };
     whitelabel: {
         type: "string";
-        default: any;
+        default: string;
         description: string;
     };
     cdn: {
@@ -28,10 +51,6 @@ declare const _default: import("@reliverse/rempts").Command<{
         default: true;
         description: string;
     };
-    /**
-     * - 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: string;
@@ -40,5 +59,10 @@ declare const _default: import("@reliverse/rempts").Command<{
         type: "string";
         description: string;
     };
+    unpack: {
+        type: "boolean";
+        default: false;
+        description: string;
+    };
 }>;
 export default _default;

package/bin/app/pack/cmd.js

@@ -1,73 +1,283 @@
 import path from "@reliverse/pathkit";
 import { relinka } from "@reliverse/relinka";
-import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { defineCommand, defineArgs } 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);
+import fs from "node:fs/promises";
+import stripJsonComments from "strip-json-comments";
+import { isBinaryExt } from "../../libs/sdk/sdk-impl/utils/binary.js";
+const WHITELABEL_DEFAULT = "DLER";
+const TEMPLATE_VAR = (name, whitelabel) => `${whitelabel}_TPL_${name.toUpperCase()}`;
+const TPLS_DIR = "templates";
+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);
 };
-const getFileMetadata = async (file) => {
-  const stats = await fs.stat(file);
-  const hash = await hashFile(file);
-  return {
-    updatedAt: stats.mtime.toISOString(),
-    updatedHash: hash
-  };
+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
+    };
+  }
+};
+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 {};
+};
+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("log", `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);
+  }
+};
+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}`);
+};
+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");
 };
 export default defineCommand({
   meta: {
     name: "pack",
-    version: "1.1.0",
-    description: "Packs a directory of templates into TS modules"
+    version: "1.2.0",
+    description: "Pack templates into TS modules or --unpack them back to files"
   },
   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" },
+    input: {
+      type: "positional",
+      required: true,
+      description: "Input directory (pack) or aggregator file (unpack)"
+    },
+    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" },
+    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)"
+      description: "Update existing templates and add new ones (pack mode only)"
     },
-    /**
-     * - 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)"
+      description: "Comma-separated list of specific files to update"
     },
     lastUpdate: {
       type: "string",
-      description: "Override lastUpdate timestamp (format: 2025-06-06T14:33:09.240Z)"
+      description: "Override lastUpdate timestamp (pack mode only)"
+    },
+    unpack: {
+      type: "boolean",
+      default: false,
+      description: "Unpack templates from an aggregator file"
     }
   }),
   async run({ args }) {
     if (args.cdn) throw new Error("Remote CDN support is not implemented yet.");
-    const dirToProcess = path.resolve(args.dir);
+    if (args.unpack) {
+      const aggrPath = path.resolve(args.input);
+      const outDir2 = path.resolve(args.output);
+      try {
+        const stat = await fs.stat(aggrPath);
+        if (!stat.isFile() || !aggrPath.endsWith(".ts")) {
+          throw new Error("Input for --unpack must be a TypeScript aggregator file (*.ts)");
+        }
+      } catch (err) {
+        relinka("error", err.message);
+        process.exit(1);
+      }
+      relinka("info", `Unpacking templates from ${aggrPath} to ${outDir2}`);
+      try {
+        await unpackTemplates(aggrPath, outDir2, args.force);
+      } catch (err) {
+        relinka("error", err.message);
+        process.exit(1);
+      }
+      return;
+    }
+    const dirToProcess = path.resolve(args.input);
     const outDir = path.resolve(args.output);
     const outDirName = path.basename(outDir);
     const typesFile = `${outDirName}-types.ts`;
     const modFile = `${outDirName}-mod.ts`;
+    relinka("info", `Packing templates from ${dirToProcess} to ${outDir}`);
     const filesToUpdate = args.files ? new Set(args.files.split(",").map((f) => f.trim())) : null;
     let existingTemplates = {};
     try {
@@ -84,6 +294,7 @@ export default defineCommand({
         if (args.update) {
           try {
             const modPath = path.join(outDir, modFile);
+            const jiti = createJiti(process.cwd());
             const mod2 = await jiti.import(modPath);
             existingTemplates = mod2?.DLER_TEMPLATES || mod2?.default || {};
           } catch (loadError) {
@@ -105,36 +316,13 @@ export default defineCommand({
     try {
       await fs.access(path.join(outDir, typesFile));
     } catch {
-      const typesContent = `export type FileContent = string | Record<string, unknown>;
-export interface FileMetadata {
-  updatedAt?: string;
-  updatedHash?: string;
-}
-export interface TemplatesFileContent {
-  content: FileContent;
-  type: "text" | "json" | "binary";
-  hasError?: boolean;
-  jsonComments?: Record<number, string>;
-  binaryHash?: string;
-  metadata?: FileMetadata;
-}
-export interface TemplateConfig {
-  files: Record<string, TemplatesFileContent>;
-}
-export interface Template {
-  name: string;
-  description: string;
-  config: TemplateConfig;
-  updatedAt?: string;
-}
-export interface Templates extends Record<string, Template> {}
-`;
-      await fs.writeFile(path.join(outDir, typesFile), typesContent);
+      await writeTypesFile(outDir, outDirName);
     }
     const aggregatedImports = [];
     const aggregatedEntries = [];
     const mapEntries = [];
     for (const tplName of templateDirs) {
+      relinka("info", `Processing template: ${tplName}`);
       const absTplDir = path.join(dirToProcess, tplName);
       const allFiles = await walkDir(absTplDir);
       const filesRecord = {};
@@ -151,11 +339,15 @@ export interface Templates extends Record<string, Template> {}
         const fileMetadata = await getFileMetadata(absFile);
         const existingFile = existingFiles[rel];
         const existingMetadata = existingFile?.metadata;
-        if (existingMetadata && (existingMetadata.updatedHash === fileMetadata.updatedHash || fileMetadata.updatedAt <= existingMetadata.updatedAt)) {
+        if (existingMetadata?.updatedHash && fileMetadata.updatedHash && (existingMetadata.updatedHash === fileMetadata.updatedHash || fileMetadata.updatedAt && existingMetadata.updatedAt && fileMetadata.updatedAt <= existingMetadata.updatedAt)) {
           filesRecord[rel] = existingFile;
           continue;
         }
-        const meta = await readFileForTemplate(absFile);
+        const meta = await readFileForTemplate(
+          absFile,
+          rel,
+          path.join(outDir, TPLS_DIR, BINARIES_DIR)
+        );
         if (meta.type === "binary") {
           const hash = await hashFile(absFile);
           const ext = path.extname(absFile);
@@ -176,12 +368,6 @@ export interface Templates extends Record<string, Template> {}
           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,
@@ -190,10 +376,11 @@ export interface Templates extends Record<string, Template> {}
       }
       const varName = TEMPLATE_VAR(tplName, args.whitelabel);
       const code = [];
-      const hasPackageJson = Object.values(filesRecord).some(
+      const hasPackageJson = Object.keys(filesRecord).some((rel) => rel.endsWith("package.json")) || Object.values(filesRecord).some(
         (f) => f.type === "json" && f.content && typeof f.content === "object" && "name" in f.content
       );
-      const hasTSConfig = Object.values(filesRecord).some(
+      const tsconfigPathRe = /(?:^|\/)tsconfig(?:\.[^/]+)?\.json$/;
+      const hasTSConfig = Object.keys(filesRecord).some((rel) => tsconfigPathRe.test(rel)) || Object.values(filesRecord).some(
         (f) => f.type === "json" && f.content && typeof f.content === "object" && "compilerOptions" in f.content
       );
       if (hasPackageJson || hasTSConfig) {
@@ -219,7 +406,7 @@ export interface Templates extends Record<string, Template> {}
         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, "},");
+          const metadataStr = JSON.stringify(meta.metadata, null, 2).replace(/^/gm, "        ").replace(/^ {7} {/m, " {").replace(/^ {8}}/m, "        }").replace(/"([a-zA-Z0-9_]+)":/g, "$1:").replace(/\n(\s*)}/, ",\n$1}").replace(/}$/m, "},");
           code.push(`        metadata:${metadataStr}`);
         }
         if (meta.type === "binary") {
@@ -230,31 +417,33 @@ export interface Templates extends Record<string, Template> {}
           code.push(`        content: \`${escapeTemplateString(meta.content)}\`,`);
           code.push('        type: "text",');
         } else {
-          const clone = { ...meta.content };
+          let clone;
           let sat = "";
-          if (rel.endsWith("package.json")) {
-            sat = " satisfies PackageJson";
-          } else if (rel.endsWith("tsconfig.json")) {
-            sat = " satisfies TSConfig";
+          try {
+            clone = JSON.parse(JSON.stringify(meta.content));
+            if (rel.endsWith("package.json")) {
+              sat = " satisfies PackageJson";
+            } else if (tsconfigPathRe.test(rel)) {
+              sat = " satisfies TSConfig";
+            }
+          } catch (error) {
+            clone = {};
+            relinka("error", `Failed to process JSON content for ${rel}: ${error}`);
           }
-          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) => {
+          const jsonStr = JSON.stringify(clone, null, 2).split("\n").map((line, i) => {
             if (i === 0) return line;
-            return "        " + line.replace(/"([a-zA-Z0-9_]+)":/g, "$1:");
-          }).join("\n").replace(/,?\s*}(\s*)$/, "}$1").replace(/,\s*,/g, ",");
+            return `        ${line.replace(/"([a-zA-Z0-9_]+)":/g, "$1:")}`;
+          }).join("\n").replace(/\n(\s*)}/, ",\n$1}").replace(/,\s*,/g, ",");
           code.push(`        content: ${jsonStr}${sat},`);
           code.push('        type: "json",');
         }
-        if (meta.hasError) code.push("        hasError: true,");
-        code.push(`      }${isLast ? "," : ","}`);
+        if (meta.hasError) {
+          code.push("        hasError: true,");
+          if (meta.error) {
+            code.push(`        error: "${escapeTemplateString(meta.error)}",`);
+          }
+        }
+        code.push(`      }${isLast ? "" : ","}`);
       });
       code.push("    },");
       code.push("  },");
@@ -281,6 +470,13 @@ export interface Templates extends Record<string, Template> {}
       } else if (!args.update) {
         relinka("log", `Creating template: ${tplName}`);
       }
+      const filesWithErrors = Object.entries(filesRecord).filter(([_, meta]) => meta.hasError);
+      if (filesWithErrors.length > 0) {
+        relinka("warn", `Template ${tplName} has files with errors:`);
+        for (const [file, meta] of filesWithErrors) {
+          relinka("warn", `  - ${file}: ${meta.error || "Unknown error"}`);
+        }
+      }
       await fs.writeFile(templatePath, code.join("\n"));
       aggregatedImports.push(`import { ${varName} } from "./${TPLS_DIR}/${tplName}";`);
       aggregatedEntries.push(`  ${tplName}: ${varName},`);
@@ -294,11 +490,11 @@ export interface Templates extends Record<string, Template> {}
       ...aggregatedEntries,
       "};",
       "",
-      `export const ${WL}_TEMPLATES = ${WL}_TEMPLATES_OBJ as const;`,
+      `export const ${WL}_TEMPLATES = ${WL}_TEMPLATES_OBJ;`,
       "",
-      `export interface ${WL}_TEMPLATE_NAMES extends keyof typeof ${WL}_TEMPLATES {}`,
+      `export type ${WL}_TEMPLATE_NAMES = keyof typeof ${WL}_TEMPLATES;`,
       "",
-      `export const dlerTemplatesMap: Record<string, ${WL}_TEMPLATE_NAMES> = {`,
+      `export const ${WL.toLowerCase()}TemplatesMap: Record<string, ${WL}_TEMPLATE_NAMES> = {`,
       ...mapEntries,
       "};"
     ];
@@ -306,9 +502,15 @@ export interface Templates extends Record<string, Template> {}
     const templatePaths = templateDirs.map(
       (tpl) => path.relative(process.cwd(), path.join(outDir, TPLS_DIR, `${tpl}.ts`))
     );
-    relinka("log", `Packed ${templateDirs.length} templates into ${modFile}:`);
+    relinka("success", `Packed ${templateDirs.length} templates into ${modFile}:`);
     for (const p of templatePaths) {
       relinka("log", `- ${p}`);
     }
+    const binaryCount = Object.values(existingTemplates).reduce((count, template) => {
+      return count + Object.values(template.config.files).filter((file) => file.type === "binary").length;
+    }, 0);
+    if (binaryCount > 0) {
+      relinka("info", `  - ${TPLS_DIR}/${BINARIES_DIR}/* (${binaryCount} binary files)`);
+    }
   }
 });

package/bin/libs/cfg/cfg-impl/rse-config/rse-impl/rse-define.d.ts

@@ -1,20 +1,20 @@
 import type { RseConfig } from "./rse-types";
 export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
-    version?: string | undefined;
     $schema?: "./schema.json" | "https://reliverse.org/schema.json" | undefined;
     projectName?: string | undefined;
     projectAuthor?: string | undefined;
     projectDescription?: string | undefined;
+    version?: string | undefined;
     projectLicense?: string | undefined;
     projectRepository?: string | undefined;
     projectDomain?: string | undefined;
     projectGitService?: "none" | "github" | "gitlab" | "bitbucket" | undefined;
     projectDeployService?: "none" | "vercel" | "netlify" | "railway" | "deno" | undefined;
-    projectPackageManager?: "bun" | "npm" | "yarn" | "pnpm" | undefined;
-    projectState?: "created" | "creating" | undefined;
-    projectCategory?: "cli" | "unknown" | "browser" | "website" | "vscode" | "library" | "mobile" | undefined;
+    projectPackageManager?: "npm" | "pnpm" | "bun" | "yarn" | undefined;
+    projectState?: "creating" | "created" | undefined;
+    projectCategory?: "cli" | "unknown" | "website" | "vscode" | "browser" | "library" | "mobile" | undefined;
     projectSubcategory?: "unknown" | "e-commerce" | "tool" | undefined;
-    projectFramework?: "rempts" | "npm-jsr" | "unknown" | "vue" | "svelte" | "vscode" | "nextjs" | "vite" | "remix" | "astro" | "nuxt" | "solid" | "qwik" | "wxt" | "lynx" | "react-native" | "expo" | "capacitor" | "ionic" | "electron" | "tauri" | "neutralino" | "citty" | "commander" | "cac" | "meow" | "yargs" | "webextension" | "browser-extension" | undefined;
+    projectFramework?: "rempts" | "npm-jsr" | "unknown" | "vscode" | "nextjs" | "vite" | "svelte" | "remix" | "astro" | "nuxt" | "solid" | "qwik" | "vue" | "wxt" | "lynx" | "react-native" | "expo" | "capacitor" | "ionic" | "electron" | "tauri" | "neutralino" | "citty" | "commander" | "cac" | "meow" | "yargs" | "webextension" | "browser-extension" | undefined;
     projectTemplate?: "unknown" | "blefnk/relivator-nextjs-template" | "blefnk/relivator-docker-template" | "blefnk/next-react-ts-src-minimal" | "blefnk/all-in-one-nextjs-template" | "blefnk/create-t3-app" | "blefnk/create-next-app" | "blefnk/astro-starlight-template" | "blefnk/versator-nextjs-template" | "blefnk/relivator-lynxjs-template" | "blefnk/relivator-react-native-template" | "reliverse/template-browser-extension" | "microsoft/vscode-extension-samples" | "microsoft/vscode-extension-template" | "rsetarter-template" | "blefnk/deno-cli-tutorial" | undefined;
     projectTemplateDate?: string | undefined;
     features?: {
@@ -38,15 +38,15 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
         analytics?: "unknown" | "vercel" | undefined;
         authentication?: "unknown" | "better-auth" | "clerk" | "next-auth" | "supabase-auth" | "auth0" | undefined;
         api?: "rest" | "unknown" | "hono" | "trpc" | "graphql" | undefined;
-        testing?: "bun" | "unknown" | "jest" | "vitest" | "playwright" | "cypress" | undefined;
+        testing?: "unknown" | "bun" | "vitest" | "jest" | "playwright" | "cypress" | undefined;
         stateManagement?: "unknown" | "zustand" | "jotai" | "redux-toolkit" | undefined;
         formManagement?: "unknown" | "react-hook-form" | "formik" | undefined;
-        styling?: "unknown" | "sass" | "tailwind" | "styled-components" | "css-modules" | undefined;
+        styling?: "unknown" | "tailwind" | "styled-components" | "css-modules" | "sass" | undefined;
         uiComponents?: "unknown" | "shadcn-ui" | "chakra-ui" | "material-ui" | undefined;
         databaseLibrary?: "unknown" | "drizzle" | "prisma" | "supabase" | undefined;
-        databaseProvider?: "unknown" | "pg" | "mysql" | "sqlite" | "mongodb" | undefined;
-        linting?: "eslint" | "unknown" | undefined;
-        formatting?: "biome" | "unknown" | undefined;
+        databaseProvider?: "sqlite" | "unknown" | "pg" | "mysql" | "mongodb" | undefined;
+        linting?: "unknown" | "eslint" | undefined;
+        formatting?: "unknown" | "biome" | undefined;
         payment?: "unknown" | "stripe" | undefined;
         monitoring?: "unknown" | "sentry" | undefined;
         logging?: "unknown" | "axiom" | undefined;
@@ -75,7 +75,7 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
         indentStyle?: "space" | "tab" | undefined;
         quoteMark?: "single" | "double" | undefined;
         semicolons?: boolean | undefined;
-        trailingComma?: "all" | "none" | "es5" | undefined;
+        trailingComma?: "none" | "es5" | "all" | undefined;
         bracketSpacing?: boolean | undefined;
         arrowParens?: "always" | "avoid" | undefined;
         tabWidth?: number | undefined;
@@ -83,7 +83,7 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
         dontRemoveComments?: boolean | undefined;
         shouldAddComments?: boolean | undefined;
         typeOrInterface?: "type" | "interface" | "mixed" | undefined;
-        importOrRequire?: "import" | "require" | "mixed" | undefined;
+        importOrRequire?: "mixed" | "import" | "require" | undefined;
         cjsToEsm?: boolean | undefined;
         modernize?: {
             replaceFs?: boolean | undefined;
@@ -96,7 +96,7 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
         importSymbol?: string | undefined;
     } | undefined;
     monorepo?: {
-        type?: "bun" | "pnpm" | "none" | "turborepo" | "nx" | undefined;
+        type?: "none" | "turborepo" | "nx" | "pnpm" | "bun" | undefined;
         packages?: string[] | undefined;
         sharedPackages?: string[] | undefined;
     } | undefined;
@@ -113,7 +113,7 @@ export declare const defineConfigRse: (userConfig?: Partial<RseConfig>) => {
     repoBranch?: string | undefined;
     repoPrivacy?: "unknown" | "public" | "private" | undefined;
     projectArchitecture?: "unknown" | "fullstack" | "separated" | undefined;
-    projectRuntime?: "bun" | "node" | "deno" | undefined;
+    projectRuntime?: "bun" | "deno" | "node" | undefined;
     skipPromptsUseAutoBehavior?: boolean | undefined;
     deployBehavior?: "prompt" | "autoYes" | "autoNo" | undefined;
     depsBehavior?: "prompt" | "autoYes" | "autoNo" | undefined;

package/bin/libs/cfg/cfg-impl/rse-config/rse-impl/rse-repair.js

@@ -12,7 +12,7 @@ export function repairAndParseJSON(raw) {
   try {
     const repaired = jsonrepair(raw);
     return JSON.parse(repaired);
-  } catch (error) {
+  } catch (_error) {
     return null;
   }
 }

package/bin/libs/cfg/cfg-impl/rse-config/rse-impl/rse-update.js

@@ -10,7 +10,7 @@ import { getBackupAndTempPaths } from "./rse-utils.js";
 function deepMerge(target, source) {
   const result = { ...target };
   for (const key in source) {
-    if (!Object.prototype.hasOwnProperty.call(source, key)) continue;
+    if (!Object.hasOwn(source, key)) continue;
     const sourceValue = source[key];
     const targetValue = target[key];
     if (sourceValue !== void 0) {

package/bin/libs/sdk/sdk-impl/config/info.js

@@ -1,5 +1,5 @@
 import { endPrompt, startPrompt } from "@reliverse/rempts";
-const version = "1.7.50";
+const version = "1.7.52";
 export async function showStartPrompt(isDev) {
   await startPrompt({
     titleColor: "inverse",

package/bin/libs/sdk/sdk-impl/config/init.js

@@ -9,7 +9,7 @@ export async function ensureDlerConfig(isDev) {
   const configExists = await fs.pathExists(configPath);
   if (configExists) return;
   try {
-    let pkgDescription = void 0;
+    let pkgDescription;
     try {
       const pkg = await readPackageJSON();
       if (pkg && typeof pkg.description === "string" && pkg.description.trim()) {

package/bin/libs/sdk/sdk-mod.d.ts

@@ -75,10 +75,6 @@ export type { CommentStyle, FileExtension, CommentMapping } from "./sdk-impl/uti
 export { DEFAULT_COMMENT, COMMENT_MAP, getCommentPrefix } from "./sdk-impl/utils/comments.js";
 export { detectFileType, detectBufferType, detectStreamType, isBinary, getMimeType, } from "./sdk-impl/utils/file-type.js";
 export { finalizeBuild, finalizePub } from "./sdk-impl/utils/finalize.js";
-export { WHITELABEL_DEFAULT, JSON_EXTS, TEMPLATE_VAR, TPLS_DIR, BINARIES_DIR, isJsonExt, } from "./sdk-impl/utils/pack-unpack/pu-constants.js";
-export { walkDir, detectFileTypePU, readFileForTemplate, escapeTemplateString, } from "./sdk-impl/utils/pack-unpack/pu-file-utils.js";
-export type { FileContent, FileType, FileMetadata, TemplatesFileContent, TemplateConfig, Template, Templates, } from "./sdk-impl/utils/pack-unpack/pu-types.js";
-export { extractJsonComments, stripComments } from "./sdk-impl/utils/pack-unpack/pub-json-utils.js";
 export { resolveCrossLibs, resolveAllCrossLibs } from "./sdk-impl/utils/resolve-cross-libs.js";
 export { useAggregator } from "./sdk-impl/utils/tools-agg.js";
 export { printUsage } from "./sdk-impl/utils/tools-impl.js";

package/bin/libs/sdk/sdk-mod.js

@@ -164,21 +164,6 @@ export {
   getMimeType
 } from "./sdk-impl/utils/file-type.js";
 export { finalizeBuild, finalizePub } from "./sdk-impl/utils/finalize.js";
-export {
-  WHITELABEL_DEFAULT,
-  JSON_EXTS,
-  TEMPLATE_VAR,
-  TPLS_DIR,
-  BINARIES_DIR,
-  isJsonExt
-} from "./sdk-impl/utils/pack-unpack/pu-constants.js";
-export {
-  walkDir,
-  detectFileTypePU,
-  readFileForTemplate,
-  escapeTemplateString
-} from "./sdk-impl/utils/pack-unpack/pu-file-utils.js";
-export { extractJsonComments, stripComments } from "./sdk-impl/utils/pack-unpack/pub-json-utils.js";
 export { resolveCrossLibs, resolveAllCrossLibs } from "./sdk-impl/utils/resolve-cross-libs.js";
 export { useAggregator } from "./sdk-impl/utils/tools-agg.js";
 export { printUsage } from "./sdk-impl/utils/tools-impl.js";

package/package.json

@@ -9,11 +9,11 @@
     "@reliverse/rempts": "^1.7.28",
     "@reliverse/runtime": "^1.0.3",
     "@rollup/plugin-alias": "^5.1.1",
-    "@rollup/plugin-commonjs": "^28.0.5",
+    "@rollup/plugin-commonjs": "^28.0.6",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-replace": "^6.0.2",
-    "@rollup/pluginutils": "^5.1.4",
+    "@rollup/pluginutils": "^5.2.0",
     "@sinclair/typebox": "^0.34.35",
     "autoprefixer": "^10.4.21",
     "c12": "^3.0.4",
@@ -44,6 +44,7 @@
     "rollup-plugin-dts": "^6.2.1",
     "scule": "^1.3.0",
     "semver": "^7.7.2",
+    "strip-json-comments": "^5.0.2",
     "tinyglobby": "^0.2.14",
     "ts-morph": "^26.0.0",
     "untyped": "^2.0.0"
@@ -53,7 +54,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.7.50",
+  "version": "1.7.52",
   "keywords": [
     "reliverse",
     "cli",

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

@@ -1,37 +0,0 @@
-declare const _default: import("@reliverse/rempts").Command<{
-    templatesDir: {
-        type: "positional";
-        required: true;
-        description: string;
-    };
-    output: {
-        type: "string";
-        default: string;
-        description: string;
-    };
-    cdn: {
-        type: "string";
-        description: string;
-    };
-    deleteTemplates: {
-        type: "boolean";
-        description: string;
-        default: false;
-    };
-    "dry-run": {
-        type: "boolean";
-        description: string;
-        default: false;
-    };
-    force: {
-        type: "boolean";
-        description: string;
-        default: false;
-    };
-    cleanup: {
-        type: "boolean";
-        description: string;
-        default: false;
-    };
-}>;
-export default _default;

package/bin/app/unpack/cmd.js

@@ -1,200 +0,0 @@
-import path from "@reliverse/pathkit";
-import { relinka } from "@reliverse/relinka";
-import { defineArgs, defineCommand } from "@reliverse/rempts";
-import { createJiti } from "jiti";
-import { promises as fs } from "node:fs";
-import { TPLS_DIR, BINARIES_DIR } from "../../libs/sdk/sdk-impl/utils/pack-unpack/pu-constants.js";
-const jiti = createJiti(import.meta.url);
-async function removeEmptyDirs(dirPath) {
-  if (!await fs.access(dirPath).then(() => true).catch(() => false))
-    return;
-  const entries = await fs.readdir(dirPath);
-  if (entries.length === 0) {
-    await fs.rmdir(dirPath);
-    const parentDir = path.dirname(dirPath);
-    if (parentDir !== dirPath) {
-      await removeEmptyDirs(parentDir);
-    }
-  }
-}
-async function deleteTemplates(templatesDir, templatesDirName, dryRun) {
-  const modFile = `${templatesDirName}-mod.ts`;
-  const typesFile = `${templatesDirName}-types.ts`;
-  const implDir = path.join(templatesDir, TPLS_DIR);
-  const binariesDir = path.join(implDir, BINARIES_DIR);
-  const filesToRemove = [path.join(templatesDir, modFile), path.join(templatesDir, typesFile)];
-  try {
-    const templateFiles = await fs.readdir(implDir);
-    for (const file of templateFiles) {
-      if (file.endsWith(".ts")) {
-        filesToRemove.push(path.join(implDir, file));
-      }
-    }
-  } catch (error) {
-    if (error.code !== "ENOENT") {
-      throw error;
-    }
-  }
-  for (const file of filesToRemove) {
-    if (dryRun) {
-      relinka("log", `[DRY RUN] Would remove: ${file}`);
-      continue;
-    }
-    try {
-      await fs.unlink(file);
-      relinka("log", `Removed: ${file}`);
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        relinka("warn", `Failed to remove ${file}: ${error.message}`);
-      }
-    }
-  }
-  try {
-    if (await fs.access(binariesDir).then(() => true).catch(() => false)) {
-      if (dryRun) {
-        relinka("log", `[DRY RUN] Would remove directory: ${binariesDir}`);
-      } else {
-        await fs.rm(binariesDir, { recursive: true });
-        relinka("log", `Removed directory: ${binariesDir}`);
-      }
-    }
-  } catch (error) {
-    relinka("warn", `Failed to remove binaries directory: ${error.message}`);
-  }
-  await removeEmptyDirs(implDir);
-  await removeEmptyDirs(templatesDir);
-}
-export default defineCommand({
-  meta: {
-    name: "unpack",
-    version: "1.1.0",
-    description: "Creates file structure from packed templates"
-  },
-  args: defineArgs({
-    templatesDir: { type: "positional", required: true, description: "Dir containing *-mod.ts" },
-    output: { type: "string", default: "unpacked", description: "Where to write files" },
-    cdn: {
-      type: "string",
-      description: "Remote CDN base for binary assets download (not yet implemented)"
-    },
-    deleteTemplates: {
-      type: "boolean",
-      description: "Delete template implementation files (*-mod.ts, *-types.ts, etc.)",
-      default: false
-    },
-    "dry-run": {
-      type: "boolean",
-      description: "Preview changes without applying them",
-      default: false
-    },
-    force: {
-      type: "boolean",
-      description: "Force overwrite existing files",
-      default: false
-    },
-    cleanup: {
-      type: "boolean",
-      description: "Delete output directory before unpacking",
-      default: false
-    }
-  }),
-  async run({ args }) {
-    if (args.cdn) throw new Error("Remote CDN support is not implemented yet.");
-    const templatesDir = path.resolve(args.templatesDir);
-    const templatesDirName = path.basename(templatesDir);
-    const modFile = `${templatesDirName}-mod.ts`;
-    const modPath = path.join(templatesDir, modFile);
-    if (args.deleteTemplates) {
-      await deleteTemplates(templatesDir, templatesDirName, args["dry-run"]);
-      if (args["dry-run"]) {
-        relinka("log", "[DRY RUN] Templates deletion completed");
-      } else {
-        relinka("log", "Templates deletion completed");
-      }
-      return;
-    }
-    if (args.cleanup) {
-      try {
-        await fs.rm(args.output, { recursive: true, force: true });
-        await fs.mkdir(args.output, { recursive: true });
-        relinka("log", `Cleaned output directory: ${args.output}`);
-      } catch (error) {
-        if (error.code !== "ENOENT") {
-          throw error;
-        }
-      }
-    }
-    const mod = await jiti.import(modPath);
-    const templatesObj = mod?.DLER_TEMPLATES || mod?.default || (() => {
-      throw new Error(`Invalid ${modFile}`);
-    })();
-    for (const tpl of Object.values(templatesObj)) {
-      await restoreTemplate(tpl, templatesDir, args.output, args.force);
-    }
-    const relativeOutput = path.relative(process.cwd(), args.output);
-    relinka(
-      "log",
-      `Unpacked ${Object.keys(templatesObj).length} templates from ${modFile} into ${relativeOutput}${args.force ? " (--force is true, dir was overwritten)" : ""}`
-    );
-  }
-});
-const restoreTemplate = async (tpl, templatesRoot, outRoot, force) => {
-  const existingFiles = [];
-  for (const [rel, meta] of Object.entries(tpl.config.files)) {
-    const destAbs = path.join(outRoot, rel);
-    if (!force) {
-      try {
-        await fs.access(destAbs);
-        existingFiles.push(rel);
-        continue;
-      } catch {
-      }
-    }
-    await fs.mkdir(path.dirname(destAbs), { recursive: true });
-    switch (meta.type) {
-      case "binary": {
-        if (!meta.binaryHash) {
-          await fs.writeFile(destAbs, "");
-          break;
-        }
-        const ext = path.extname(rel);
-        const binPath = path.join(
-          templatesRoot,
-          TPLS_DIR,
-          BINARIES_DIR,
-          `${meta.binaryHash}${ext}`
-        );
-        await fs.copyFile(binPath, destAbs);
-        break;
-      }
-      case "text": {
-        await fs.writeFile(destAbs, meta.content, "utf8");
-        break;
-      }
-      case "json": {
-        const txt = JSON.stringify(meta.content, null, 2);
-        const withComments = meta.jsonComments ? injectComments(txt, meta.jsonComments) : txt;
-        await fs.writeFile(destAbs, withComments, "utf8");
-        break;
-      }
-    }
-  }
-  if (existingFiles.length > 0) {
-    throw new Error(
-      `Cannot unpack: ${existingFiles.length} file(s) already exist. Use --force to overwrite existing files`
-    );
-  }
-};
-const injectComments = (json, comments) => {
-  const lines = json.split("\n");
-  const entries = Object.entries(comments).map(([k, v]) => [Number(k), v]).sort((a, b) => a[0] - b[0]);
-  let offset = 0;
-  for (const [ln, comment] of entries) {
-    const idx = ln - 1 + offset;
-    const indent = lines[idx]?.match(/^\s*/)?.[0] ?? "";
-    const block = comment.split("\n").map((l) => indent + l);
-    lines.splice(idx, 0, ...block);
-    offset += block.length;
-  }
-  return lines.join("\n") + "\n";
-};

package/bin/libs/sdk/sdk-impl/utils/pack-unpack/pu-constants.d.ts

@@ -1,6 +0,0 @@
-export declare const WHITELABEL_DEFAULT = "DLER";
-export declare const JSON_EXTS: Set<string>;
-export declare const TEMPLATE_VAR: (tpl: string, wl: string) => string;
-export declare const TPLS_DIR = "tpls";
-export declare const BINARIES_DIR = "binaries";
-export declare const isJsonExt: (f: string) => boolean;

package/bin/libs/sdk/sdk-impl/utils/pack-unpack/pu-constants.js

@@ -1,7 +0,0 @@
-import path from "@reliverse/pathkit";
-export const WHITELABEL_DEFAULT = "DLER";
-export const JSON_EXTS = /* @__PURE__ */ new Set(["json", "jsonc", "json5", "jsonl"]);
-export const TEMPLATE_VAR = (tpl, wl) => `${tpl.toUpperCase()}_${wl.toUpperCase()}_TEMPLATE`;
-export const TPLS_DIR = "tpls";
-export const BINARIES_DIR = "binaries";
-export const isJsonExt = (f) => JSON_EXTS.has(path.extname(f).slice(1).toLowerCase());

package/bin/libs/sdk/sdk-impl/utils/pack-unpack/pu-file-utils.d.ts

@@ -1,5 +0,0 @@
-import type { FileType, TemplatesFileContent } from "./pu-types";
-export declare const walkDir: (dir: string) => Promise<string[]>;
-export declare const detectFileTypePU: (file: string) => Promise<FileType>;
-export declare const readFileForTemplate: (absPath: string) => Promise<TemplatesFileContent>;
-export declare const escapeTemplateString: (src: string) => string;

package/bin/libs/sdk/sdk-impl/utils/pack-unpack/pu-file-utils.js

@@ -1,40 +0,0 @@
-import path from "@reliverse/pathkit";
-import { promises as fs } from "node:fs";
-import { isBinaryExt } from "../binary.js";
-import { isJsonExt } from "./pu-constants.js";
-import { extractJsonComments, stripComments } from "./pub-json-utils.js";
-export const walkDir = async (dir) => {
-  const entries = [];
-  for (const entry of await fs.readdir(dir, { withFileTypes: true })) {
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      entries.push(...await walkDir(full));
-    } else {
-      entries.push(full);
-    }
-  }
-  return entries;
-};
-export const detectFileTypePU = async (file) => {
-  if (await isBinaryExt(file)) return "binary";
-  if (isJsonExt(file)) return "json";
-  return "text";
-};
-export const readFileForTemplate = async (absPath) => {
-  const type = await detectFileTypePU(absPath);
-  try {
-    if (type === "binary") {
-      return { type, content: "" };
-    }
-    const data = await fs.readFile(absPath, "utf8");
-    if (type === "json") {
-      const jsonComments = extractJsonComments(data);
-      const json = JSON.parse(stripComments(data));
-      return { type, content: json, jsonComments };
-    }
-    return { type, content: data };
-  } catch {
-    return { type, content: "", hasError: true };
-  }
-};
-export const escapeTemplateString = (src) => src.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");

package/bin/libs/sdk/sdk-impl/utils/pack-unpack/pu-types.d.ts

@@ -1,24 +0,0 @@
-export type FileContent = string | Record<string, unknown>;
-export type FileType = "text" | "json" | "binary";
-export interface FileMetadata {
-    updatedAt: string;
-    updatedHash: string;
-}
-export interface TemplatesFileContent {
-    content: FileContent;
-    type: FileType;
-    hasError?: boolean;
-    jsonComments?: Record<number, string>;
-    binaryHash?: string;
-    metadata?: FileMetadata;
-}
-export interface TemplateConfig {
-    files: Record<string, TemplatesFileContent>;
-}
-export interface Template {
-    name: string;
-    description: string;
-    config: TemplateConfig;
-    updatedAt: string;
-}
-export type Templates = Record<string, Template>;

package/bin/libs/sdk/sdk-impl/utils/pack-unpack/pub-json-utils.d.ts

@@ -1,17 +0,0 @@
-/**
- * Helpers for reading / writing JSON-with-comments files while
- * preserving (or later reinjecting) on–line and block comments.
- *
- * Supported comment styles:
- *   // single-line
- *   /* … *\/
- *   /** … *\/
- */
-export declare const extractJsonComments: (raw: string) => Record<number, string> | undefined;
-/**
- * Very small "strip comments" helper:
- * removes // … and /* … *\/  (including multi-line).
- * This is intentionally simple; for complex JSONC we may want
- * use something like `strip-json-comments` in the future.
- */
-export declare const stripComments: (raw: string) => string;

package/bin/libs/sdk/sdk-impl/utils/pack-unpack/pub-json-utils.js

@@ -1,46 +0,0 @@
-export const extractJsonComments = (raw) => {
-  const out = {};
-  const lines = raw.split("\n");
-  for (let i = 0; i < lines.length; ) {
-    const line = lines[i];
-    if (!line) {
-      i += 1;
-      continue;
-    }
-    const trimmed = line.trimStart();
-    const indent = line.length - trimmed.length;
-    if (trimmed.startsWith("//")) {
-      out[i + 1] = trimmed.slice(2).trimStart();
-      i += 1;
-      continue;
-    }
-    if (trimmed.startsWith("/*")) {
-      const isSupported = trimmed.startsWith("/**") || trimmed.startsWith("/*");
-      if (!isSupported) {
-        i += 1;
-        continue;
-      }
-      const buff = [trimmed];
-      let j = i + 1;
-      while (j < lines.length) {
-        const currentLine = lines[j];
-        if (!currentLine) {
-          j += 1;
-          continue;
-        }
-        if (currentLine.trimEnd().endsWith("*/")) {
-          buff.push(currentLine.slice(indent));
-          break;
-        }
-        buff.push(currentLine.slice(indent));
-        j += 1;
-      }
-      out[i + 1] = buff.join("\n");
-      i = j + 1;
-      continue;
-    }
-    i += 1;
-  }
-  return Object.keys(out).length ? out : void 0;
-};
-export const stripComments = (raw) => raw.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\r\n]*/g, "");