@reliverse/dler 1.2.0

package/bin/libs/sdk/sdk-impl/spells/spells-parser.js

@@ -0,0 +1,60 @@
+const SPELL_REGEX = /<dler-([a-z-]+)-(?:"([^"]+)")?-?(?:{([^}]+)})?>/;
+export const parseParams = (paramsStr) => {
+  const defaultParams = {
+    hooked: false
+  };
+  if (!paramsStr) return defaultParams;
+  const params = { ...defaultParams };
+  for (const param of paramsStr.split(",")) {
+    const [key, value] = param.trim().split("=");
+    if (key && value !== void 0) {
+      if (value === "true") params[key] = true;
+      else if (value === "false") params[key] = false;
+      else if (!Number.isNaN(Number(value))) params[key] = Number(value);
+      else params[key] = value;
+    }
+  }
+  return params;
+};
+export const parseSpellFromComment = (line, lineNumber, fileName) => {
+  const match = line.match(SPELL_REGEX);
+  if (!match) return null;
+  const [fullMatch, spellType, value, paramsStr] = match;
+  if (!spellType || !isValidSpellType(spellType)) {
+    console.warn(
+      `Unknown spell type: ${spellType} in file ${fileName}:${lineNumber}`
+    );
+    return null;
+  }
+  return {
+    type: spellType,
+    params: parseParams(paramsStr),
+    value,
+    lineNumber,
+    fullMatch,
+    fileName
+  };
+};
+export const extractSpellsFromFile = async (filePath, content) => {
+  const lines = content.split("\n");
+  const spells = [];
+  lines.forEach((line, index) => {
+    const spell = parseSpellFromComment(line, index + 1, filePath);
+    if (spell) spells.push(spell);
+  });
+  return spells;
+};
+const isValidSpellType = (type) => {
+  const validTypes = [
+    "replace-line",
+    "rename-file",
+    "remove-comment",
+    "remove-line",
+    "remove-file",
+    "transform-content",
+    "copy-file",
+    "move-file",
+    "insert-at"
+  ];
+  return validTypes.includes(type);
+};

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

@@ -0,0 +1,149 @@
+import fs from "fs-extra";
+import path from "pathe";
+export async function useAggregator({
+  inputDir,
+  isRecursive,
+  outFile,
+  stripPrefix,
+  useImport,
+  useNamed
+}) {
+  const st = await fs.stat(inputDir).catch(() => null);
+  if (!st?.isDirectory()) {
+    console.error(`Error: --input is not a valid directory: ${inputDir}`);
+    process.exit(1);
+  }
+  const exts = [".ts", ".js"];
+  const filePaths = await collectFiles(inputDir, exts, isRecursive);
+  if (!filePaths.length) {
+    console.warn(`No matching .ts/.js files found in ${inputDir}`);
+  }
+  const allLines = [];
+  for (const fp of filePaths) {
+    const lines = await generateAggregatorLines(
+      fp,
+      inputDir,
+      stripPrefix,
+      useImport,
+      useNamed
+    );
+    allLines.push(...lines);
+  }
+  if (outFile.startsWith(inputDir)) {
+    console.warn(
+      `Warning: The output file is inside (or overlaps with) the input directory.
+Might re-import (or re-export) itself.
+   input: ${inputDir}
+   out: ${outFile}
+`
+    );
+  }
+  const finalText = `${allLines.join("\n")}
+`;
+  await fs.ensureFile(outFile);
+  await fs.writeFile(outFile, finalText, "utf8");
+  console.log(
+    `
+Aggregator done: wrote ${allLines.length} lines to:
+  ${outFile}`
+  );
+}
+function buildPathRelative(filePath, inputDir, stripPrefix) {
+  let resolved = path.resolve(filePath);
+  const resolvedStrip = stripPrefix ? path.resolve(stripPrefix) : "";
+  if (resolvedStrip && resolved.startsWith(resolvedStrip)) {
+    resolved = resolved.slice(resolvedStrip.length);
+  } else {
+    resolved = path.relative(path.resolve(inputDir), resolved);
+  }
+  while (resolved.startsWith(path.sep)) {
+    resolved = resolved.slice(1);
+  }
+  resolved = resolved.replace(/\\/g, "/");
+  if (resolved.toLowerCase().endsWith(".ts")) {
+    resolved = `${resolved.slice(0, -3)}.js`;
+  }
+  if (!resolved.startsWith("./") && !resolved.startsWith("../")) {
+    resolved = `./${resolved}`;
+  }
+  return resolved;
+}
+async function collectFiles(dir, exts, recursive) {
+  const found = [];
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (recursive) {
+        const sub = await collectFiles(fullPath, exts, recursive);
+        found.push(...sub);
+      }
+    } else if (entry.isFile()) {
+      if (exts.some((ext) => entry.name.toLowerCase().endsWith(ext))) {
+        found.push(fullPath);
+      }
+    }
+  }
+  return found;
+}
+async function generateAggregatorLines(filePath, inputDir, stripPrefix, useImport, useNamed) {
+  const importPath = buildPathRelative(filePath, inputDir, stripPrefix);
+  if (!useNamed) {
+    if (useImport) {
+      const ident = guessStarImportIdentifier(filePath);
+      return [`import * as ${ident} from "${importPath}";`];
+    }
+    return [`export * from "${importPath}";`];
+  }
+  const { typeNames, valueNames } = await getNamedExports(filePath);
+  if (!typeNames.length && !valueNames.length) {
+    return [];
+  }
+  if (useImport) {
+    const lines2 = [];
+    if (typeNames.length > 0) {
+      lines2.push(
+        `import type { ${typeNames.join(", ")} } from "${importPath}";`
+      );
+    }
+    if (valueNames.length > 0) {
+      lines2.push(`import { ${valueNames.join(", ")} } from "${importPath}";`);
+    }
+    return lines2;
+  }
+  const lines = [];
+  if (typeNames.length > 0) {
+    lines.push(`export type { ${typeNames.join(", ")} } from "${importPath}";`);
+  }
+  if (valueNames.length > 0) {
+    lines.push(`export { ${valueNames.join(", ")} } from "${importPath}";`);
+  }
+  return lines;
+}
+async function getNamedExports(filePath) {
+  const code = await fs.readFile(filePath, "utf-8");
+  const pattern = /^export\s+(?:async\s+)?(function|const|class|let|type|interface)\s+([A-Za-z0-9_$]+)/gm;
+  const typeNames = [];
+  const valueNames = [];
+  let match = null;
+  while (true) {
+    match = pattern.exec(code);
+    if (match === null) break;
+    const keyword = match[1];
+    const name = match[2];
+    if (keyword === "type" || keyword === "interface") {
+      typeNames.push(name);
+    } else {
+      valueNames.push(name);
+    }
+  }
+  return { typeNames, valueNames };
+}
+function guessStarImportIdentifier(filePath) {
+  const base = path.basename(filePath, path.extname(filePath));
+  let identifier = base.replace(/[^a-zA-Z0-9_$]/g, "_");
+  if (/^\d/.test(identifier)) {
+    identifier = `_${identifier}`;
+  }
+  return identifier || "file";
+}

package/bin/libs/sdk/sdk-impl/utils/tools/tools-impl.js

@@ -0,0 +1,21 @@
+import { relinka } from "@reliverse/relinka";
+export function printUsage(isDev) {
+  relinka("info", "====================");
+  relinka("info", "TOOLS USAGE EXAMPLES");
+  relinka("info", "====================");
+  relinka(
+    "info",
+    `${isDev ? "bun dev:agg" : "dler tools"} --tool agg --input <dir> --out <file> [options]`
+  );
+  if (isDev) {
+    relinka(
+      "info",
+      "bun dev:tools agg --input src/libs/sdk/sdk-impl --out src/libs/sdk/sdk-main.ts --recursive --named --strip src/libs/sdk"
+    );
+  } else {
+    relinka(
+      "info",
+      "dler tools --tool agg --input src/libs --out aggregator.ts --recursive --named"
+    );
+  }
+}

package/bin/libs/sdk/sdk-impl/utils/utils-build.js

@@ -0,0 +1,102 @@
+import { relinka } from "@reliverse/relinka";
+import fs from "fs-extra";
+import path from "pathe";
+export function getBunSourcemapOption(transpileSourcemap) {
+  relinka(
+    "verbose",
+    `Converting Bun sourcemap option from: ${transpileSourcemap}`
+  );
+  switch (transpileSourcemap) {
+    case "inline":
+      return "inline";
+    case "none":
+    case false:
+      return "none";
+    default:
+      return "external";
+  }
+}
+export function getUnifiedSourcemapOption(transpileSourcemap) {
+  relinka(
+    "verbose",
+    `Converting Unified/Rollup sourcemap option from: ${transpileSourcemap}`
+  );
+  switch (transpileSourcemap) {
+    case "external":
+    case "linked":
+      return true;
+    // Indicates separate sourcemap file
+    case "inline":
+      return "inline";
+    // Indicates inline sourcemap
+    case "none":
+    case false:
+      return false;
+    // No sourcemap
+    default:
+      return !!transpileSourcemap;
+  }
+}
+export async function renameEntryFile(isJsr, outDirBin, originalEntryFileBasename, unifiedBundlerOutExt, distJsrOutFilesExt) {
+  relinka(
+    "verbose",
+    `Attempting to rename entry file. Original basename: ${originalEntryFileBasename}, Output Dir: ${outDirBin}, isJsr=${isJsr}`
+  );
+  let sourceEntryBasename;
+  let targetEntryBasename;
+  let sourceDeclarationBasename = null;
+  let targetDeclarationBasename = null;
+  const outputExt = isJsr ? distJsrOutFilesExt : unifiedBundlerOutExt;
+  const originalBasenameNoExt = originalEntryFileBasename.split(".").slice(0, -1).join(".");
+  if (isJsr) {
+    if (originalEntryFileBasename.endsWith(".ts")) {
+      sourceEntryBasename = originalEntryFileBasename;
+      targetEntryBasename = "main.ts";
+    } else {
+      sourceEntryBasename = `${originalBasenameNoExt}.${outputExt}`;
+      targetEntryBasename = `main.${outputExt}`;
+    }
+  } else {
+    sourceEntryBasename = `${originalBasenameNoExt}.${outputExt}`;
+    targetEntryBasename = `main.${outputExt}`;
+    sourceDeclarationBasename = `${originalBasenameNoExt}.d.ts`;
+    targetDeclarationBasename = "main.d.ts";
+  }
+  const sourceEntryPath = path.join(outDirBin, sourceEntryBasename);
+  const targetEntryPath = path.join(outDirBin, targetEntryBasename);
+  const sourceDeclarationPath = sourceDeclarationBasename ? path.join(outDirBin, sourceDeclarationBasename) : null;
+  const targetDeclarationPath = targetDeclarationBasename ? path.join(outDirBin, targetDeclarationBasename) : null;
+  if (!await fs.pathExists(sourceEntryPath)) {
+    throw new Error(
+      `Entry file expected for renaming not found: ${sourceEntryPath}`
+    );
+  }
+  relinka(
+    "verbose",
+    `Found source entry file: ${sourceEntryPath}. Renaming to: ${targetEntryPath}`
+  );
+  if (sourceDeclarationPath && targetDeclarationPath) {
+    if (await fs.pathExists(sourceDeclarationPath)) {
+      relinka(
+        "verbose",
+        `Renaming declaration ${sourceDeclarationPath} to ${targetDeclarationPath}`
+      );
+      await fs.rename(sourceDeclarationPath, targetDeclarationPath);
+    } else {
+      relinka(
+        "verbose",
+        `Source declaration file not found, skipping rename: ${sourceDeclarationPath}`
+      );
+    }
+  }
+  if (sourceEntryPath !== targetEntryPath) {
+    await fs.rename(sourceEntryPath, targetEntryPath);
+    relinka("info", `Renamed entry file to ${targetEntryPath}`);
+  } else {
+    relinka(
+      "info",
+      `Source entry file ${sourceEntryPath} already has the target name. Skipping rename.`
+    );
+  }
+  return { updatedEntryFile: targetEntryBasename };
+}

package/bin/libs/sdk/sdk-impl/utils/utils-bump.js

@@ -0,0 +1,238 @@
+import { relinka } from "@reliverse/relinka";
+import fs from "fs-extra";
+import pMap from "p-map";
+import path from "pathe";
+import { readPackageJSON } from "pkg-types";
+import semver from "semver";
+import { glob } from "tinyglobby";
+import { CONCURRENCY_DEFAULT, PROJECT_ROOT } from "./utils-consts.js";
+import { readFileSafe, writeFileSafe } from "./utils-fs.js";
+const IGNORE_PATTERNS = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.next/**",
+  "**/coverage/**",
+  "**/.cache/**",
+  "**/tmp/**",
+  "**/.temp/**",
+  "**/package-lock.json",
+  "**/pnpm-lock.yaml",
+  "**/yarn.lock",
+  "**/bun.lock"
+];
+const createJsonVersionRegex = (oldVer) => new RegExp(`"version"\\s*:\\s*"${oldVer}"`, "g");
+const TS_VERSION_REGEXES = [
+  (oldVer) => new RegExp(`(export\\s+const\\s+version\\s*=\\s*["'])${oldVer}(["'])`, "g"),
+  (oldVer) => new RegExp(`(const\\s+version\\s*=\\s*["'])${oldVer}(["'])`, "g"),
+  (oldVer) => new RegExp(`(version\\s*:\\s*["'])${oldVer}(["'])`, "g"),
+  (oldVer) => new RegExp(`(VERSION\\s*=\\s*["'])${oldVer}(["'])`, "g"),
+  (oldVer) => new RegExp(
+    `(export\\s+const\\s+cliVersion\\s*=\\s*["'])${oldVer}(["'])`,
+    "g"
+  ),
+  (oldVer) => new RegExp(`(const\\s+cliVersion\\s*=\\s*["'])${oldVer}(["'])`, "g")
+];
+export async function bumpHandler(bumpMode, bumpDisable, commonPubPause, bumpFilter) {
+  if (bumpDisable || commonPubPause) {
+    relinka(
+      "info",
+      "Skipping version bump because it is either `bumpDisable: true` or `commonPubPause: true` in your dler config."
+    );
+    return;
+  }
+  const pkgPath = path.resolve("package.json");
+  if (!await fs.pathExists(pkgPath)) {
+    throw new Error("package.json not found");
+  }
+  const pkgJson = await readPackageJSON();
+  if (!pkgJson.version) {
+    throw new Error("No version field found in package.json");
+  }
+  const oldVersion = pkgJson.version;
+  if (!semver.valid(oldVersion)) {
+    throw new Error(`Invalid existing version in package.json: ${oldVersion}`);
+  }
+  relinka(
+    "info",
+    `Auto-incrementing version from ${oldVersion} using "${bumpMode}"`
+  );
+  const incremented = autoIncrementVersion(oldVersion, bumpMode);
+  if (oldVersion !== incremented) {
+    await bumpVersions(oldVersion, incremented, bumpFilter);
+    await setBumpDisabled(true, commonPubPause);
+  } else {
+    relinka("info", `Version is already at ${oldVersion}, no bump needed.`);
+  }
+}
+export async function setBumpDisabled(value, commonPubPause) {
+  if (commonPubPause && value) {
+    return;
+  }
+  const dlerCfgPath = path.join(PROJECT_ROOT, ".config/dler.ts");
+  if (!await fs.pathExists(dlerCfgPath)) {
+    relinka("info", "No .config/dler.ts found to update bumpDisable");
+    return;
+  }
+  let content = await readFileSafe(dlerCfgPath, "", "bumpDisable update");
+  content = content.replace(
+    /bumpDisable\s*:\s*(true|false)/,
+    `bumpDisable: ${value}`
+  );
+  await writeFileSafe(dlerCfgPath, content, "bumpDisable update");
+}
+function autoIncrementVersion(oldVersion, bumpMode) {
+  if (!semver.valid(oldVersion)) {
+    throw new Error(`Can't auto-increment invalid version: ${oldVersion}`);
+  }
+  const releaseTypeMap = {
+    autoMajor: "major",
+    autoMinor: "minor",
+    autoPatch: "patch"
+  };
+  const newVer = semver.inc(oldVersion, releaseTypeMap[bumpMode]);
+  if (!newVer) {
+    throw new Error(`semver.inc failed for ${oldVersion} and mode ${bumpMode}`);
+  }
+  return newVer;
+}
+async function bumpVersions(oldVersion, newVersion, bumpFilter = [
+  "package.json",
+  ".config/rse.jsonc",
+  ".config/rse.ts"
+]) {
+  relinka(
+    "verbose",
+    `Starting bumpVersions from ${oldVersion} to ${newVersion}`
+  );
+  try {
+    const filePatterns = [];
+    if (bumpFilter.length > 0) {
+      for (const filter of bumpFilter) {
+        if (filter.includes("/") || filter.includes("\\")) {
+          filePatterns.push(`**/${filter}`);
+          continue;
+        }
+        if (filter.includes(".")) {
+          filePatterns.push(`**/${filter}`);
+          continue;
+        }
+        filePatterns.push(`**/${filter}.*`);
+      }
+      relinka(
+        "verbose",
+        `Generated patterns from filters: ${filePatterns.join(", ")}`
+      );
+    } else {
+      filePatterns.push("**/package.json");
+      relinka(
+        "verbose",
+        "No filters provided, falling back to only process package.json"
+      );
+    }
+    const ignorePatterns = [
+      "**/node_modules/**",
+      "**/.git/**",
+      ...IGNORE_PATTERNS
+    ];
+    try {
+      const gitignorePath = path.join(PROJECT_ROOT, ".gitignore");
+      if (await fs.pathExists(gitignorePath)) {
+        const gitignoreContent = await fs.readFile(gitignorePath, "utf8");
+        const gitignorePatterns = gitignoreContent.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((pattern) => {
+          if (pattern.startsWith("/")) {
+            return pattern.substring(1);
+          }
+          if (pattern.endsWith("/")) {
+            return `**/${pattern}**`;
+          }
+          return `**/${pattern}`;
+        });
+        if (gitignorePatterns.length > 0) {
+          relinka(
+            "verbose",
+            `Bump will not process ${gitignorePatterns.length} patterns listed in .gitignore`
+          );
+          ignorePatterns.push(...gitignorePatterns);
+        }
+      }
+    } catch (err) {
+      relinka("verbose", `Could not process .gitignore: ${err}`);
+    }
+    const matchedFiles = await glob(filePatterns, {
+      absolute: true,
+      cwd: PROJECT_ROOT,
+      dot: false,
+      // Skip hidden files
+      ignore: ignorePatterns
+    });
+    relinka(
+      "verbose",
+      `Found ${matchedFiles.length} files to check for version bumping`
+    );
+    let modifiedCount = 0;
+    await pMap(
+      matchedFiles,
+      async (file) => {
+        try {
+          if (!await fs.pathExists(file)) {
+            relinka("verbose", `File does not exist (skipped): ${file}`);
+            return;
+          }
+          const content = await readFileSafe(file, "", "bumpVersions");
+          const modified = await updateVersionInContent(
+            file,
+            content,
+            oldVersion,
+            newVersion
+          );
+          if (modified) {
+            modifiedCount++;
+            relinka("verbose", `Updated version in: ${file}`);
+          }
+        } catch (err) {
+          relinka("error", `Error processing file ${file}: ${err}`);
+        }
+      },
+      { concurrency: CONCURRENCY_DEFAULT }
+    );
+    if (modifiedCount > 0) {
+      relinka(
+        "success",
+        `Updated version from ${oldVersion} to ${newVersion} in ${modifiedCount} file(s)`
+      );
+    } else {
+      relinka("warn", "No files were updated with the new version");
+    }
+  } catch (error) {
+    relinka("error", "Failed to bump versions:", error);
+    throw error;
+  }
+  relinka("verbose", "Exiting bumpVersions");
+}
+async function updateVersionInContent(filePath, content, oldVersion, newVersion) {
+  let updatedContent = content;
+  let changed = false;
+  if (/\.(json|jsonc|json5)$/.test(filePath)) {
+    if (content.includes(`"version": "${oldVersion}"`)) {
+      updatedContent = content.replace(
+        createJsonVersionRegex(oldVersion),
+        `"version": "${newVersion}"`
+      );
+      changed = true;
+    }
+  } else if (filePath.endsWith(".ts")) {
+    for (const regexFactory of TS_VERSION_REGEXES) {
+      const regex = regexFactory(oldVersion);
+      if (regex.test(updatedContent)) {
+        updatedContent = updatedContent.replace(regex, `$1${newVersion}$2`);
+        changed = true;
+      }
+    }
+  }
+  if (changed) {
+    await writeFileSafe(filePath, updatedContent, "version update");
+  }
+  return changed;
+}

package/bin/libs/sdk/sdk-impl/utils/utils-clean.js

@@ -0,0 +1,35 @@
+import { relinka } from "@reliverse/relinka";
+import fs from "fs-extra";
+import pMap from "p-map";
+import path from "pathe";
+import { CONCURRENCY_DEFAULT, PROJECT_ROOT } from "./utils-consts.js";
+export async function removeDistFolders(distNpmDirName, distJsrDirName, libsDirDist, libsList) {
+  const foldersToRemove = [];
+  foldersToRemove.push(distNpmDirName);
+  foldersToRemove.push(distJsrDirName);
+  if (libsList && Object.keys(libsList).length > 0) {
+    foldersToRemove.push(libsDirDist);
+  }
+  const existingFolders = [];
+  for (const folder of foldersToRemove) {
+    const folderPath = path.resolve(PROJECT_ROOT, folder);
+    if (await fs.pathExists(folderPath)) {
+      existingFolders.push(folder);
+    }
+  }
+  if (existingFolders.length > 0) {
+    await pMap(
+      existingFolders,
+      async (folder) => {
+        const folderPath = path.resolve(PROJECT_ROOT, folder);
+        if (await fs.pathExists(folderPath)) {
+          await fs.remove(folderPath);
+          relinka("verbose", `Removed: ${folderPath}`);
+        }
+      },
+      { concurrency: CONCURRENCY_DEFAULT }
+    );
+    relinka("success", "Distribution folders removed successfully");
+  }
+  return true;
+}

package/bin/libs/sdk/sdk-impl/utils/utils-consts.js

@@ -0,0 +1,17 @@
+import path from "pathe";
+export const PROJECT_ROOT = path.resolve(process.cwd());
+export const CONCURRENCY_DEFAULT = 1;
+export const tsconfigJson = "tsconfig.json";
+export const cliDomainDocs = "https://docs.reliverse.org";
+export const validExtensions = [
+  "cjs",
+  "js",
+  "mjs",
+  "ts",
+  "mts",
+  "cts"
+];
+export const SHOW_VERBOSE = {
+  getDirectorySize: false,
+  readFileSafe: false
+};

package/bin/libs/sdk/sdk-impl/utils/utils-cwd.js

@@ -0,0 +1,36 @@
+import { relinka } from "@reliverse/relinka";
+export async function validateDevCwd(isDev, paths, cliName, cliOrg = "") {
+  if (!isDev) return;
+  const projectName = cliOrg ? `@${cliOrg}/${cliName}` : cliName;
+  const currentDir = process.cwd();
+  if (!paths.some((path) => currentDir.includes(path))) {
+    const pathsList = paths.map((p) => `'${p}'`).join(", ");
+    throw new Error(
+      [
+        `\u2502  The '--dev' flag is reserved exclusively for ${projectName} developers`,
+        `\u2502  Your current directory must include one of the following paths: ${pathsList}`,
+        `\u2502  Also please make sure to use 'bun dev' instead of '${cliName} --dev'`,
+        `\u2502  Current working directory: ${currentDir}`
+      ].join("\n")
+    );
+  }
+}
+export async function withWorkingDirectory(transpileTargetDir, fn) {
+  relinka(
+    "verbose",
+    `Entering withWorkingDirectory, transpileTargetDir: ${transpileTargetDir}`
+  );
+  const originalDir = process.cwd();
+  try {
+    process.chdir(transpileTargetDir);
+    relinka("verbose", `Changed working directory to: ${transpileTargetDir}`);
+    const result = await fn();
+    return result;
+  } catch (error) {
+    relinka("error", `Error in directory ${transpileTargetDir}:`, error);
+    throw error;
+  } finally {
+    process.chdir(originalDir);
+    relinka("verbose", `Restored working directory to: ${originalDir}`);
+  }
+}