@reliverse/dler 1.2.0

package/bin/libs/sdk/sdk-impl/regular-flow.js

@@ -0,0 +1,219 @@
+import { relinka } from "@reliverse/relinka";
+import pAll from "p-all";
+import {
+  regular_buildJsrDist,
+  regular_buildNpmDist
+} from "./build/build-regular.js";
+import { regular_pubToJsr, regular_pubToNpm } from "./pub/pub-regular.js";
+import { CONCURRENCY_DEFAULT } from "./utils/utils-consts.js";
+export async function processRegularFlow(timer, isDev, coreIsCLI, libsActMode, commonPubRegistry, coreEntrySrcDir, distNpmDirName, distNpmBuilder, coreEntryFile, distJsrDryRun, distJsrFailOnWarn, commonPubPause, distJsrDirName, distJsrBuilder, transpileTarget, transpileFormat, transpileSplitting, transpileMinify, transpileSourcemap, transpilePublicPath, distJsrAllowDirty, distJsrSlowTypes, unifiedBundlerOutExt, rmDepsMode, transpileStub, transpileWatch, distJsrGenTsconfig, coreDeclarations) {
+  if (libsActMode !== "main-project-only" && libsActMode !== "main-and-libs") {
+    relinka(
+      "info",
+      "Skipping main project build/publish as libsActMode is set to 'libs-only'"
+    );
+    return;
+  }
+  switch (commonPubRegistry) {
+    case "jsr":
+      relinka(
+        "info",
+        "Initializing build process for main project to JSR only..."
+      );
+      await regular_buildJsrDist(
+        isDev,
+        true,
+        coreIsCLI,
+        coreEntrySrcDir,
+        distJsrDirName,
+        distJsrBuilder,
+        coreEntryFile,
+        transpileTarget,
+        transpileFormat,
+        transpileSplitting,
+        transpileMinify,
+        transpileSourcemap,
+        transpilePublicPath,
+        unifiedBundlerOutExt,
+        rmDepsMode,
+        timer,
+        transpileStub,
+        transpileWatch,
+        distJsrGenTsconfig,
+        coreDeclarations
+      );
+      if (!isDev) {
+        await regular_pubToJsr(
+          distJsrDryRun,
+          distJsrFailOnWarn,
+          isDev,
+          commonPubPause,
+          distJsrDirName,
+          distJsrAllowDirty,
+          distJsrSlowTypes,
+          timer
+        );
+      }
+      break;
+    case "npm":
+      relinka(
+        "info",
+        "Initializing build process for main project to NPM only..."
+      );
+      await regular_buildNpmDist(
+        isDev,
+        coreEntrySrcDir,
+        distNpmDirName,
+        distNpmBuilder,
+        coreEntryFile,
+        unifiedBundlerOutExt,
+        rmDepsMode,
+        coreIsCLI,
+        transpileTarget,
+        transpileFormat,
+        transpileSplitting,
+        transpileMinify,
+        transpileSourcemap,
+        transpilePublicPath,
+        transpileStub,
+        transpileWatch,
+        timer,
+        coreDeclarations
+      );
+      if (!isDev) {
+        await regular_pubToNpm(
+          distJsrDryRun,
+          isDev,
+          commonPubPause,
+          distNpmDirName,
+          timer
+        );
+      }
+      break;
+    case "npm-jsr": {
+      relinka(
+        "info",
+        "Initializing build process for main project to both NPM and JSR..."
+      );
+      const buildTasks = [
+        () => regular_buildJsrDist(
+          isDev,
+          true,
+          coreIsCLI,
+          coreEntrySrcDir,
+          distJsrDirName,
+          distJsrBuilder,
+          coreEntryFile,
+          transpileTarget,
+          transpileFormat,
+          transpileSplitting,
+          transpileMinify,
+          transpileSourcemap,
+          transpilePublicPath,
+          unifiedBundlerOutExt,
+          rmDepsMode,
+          timer,
+          transpileStub,
+          transpileWatch,
+          distJsrGenTsconfig,
+          coreDeclarations
+        ),
+        () => regular_buildNpmDist(
+          isDev,
+          coreEntrySrcDir,
+          distNpmDirName,
+          distNpmBuilder,
+          coreEntryFile,
+          unifiedBundlerOutExt,
+          rmDepsMode,
+          coreIsCLI,
+          transpileTarget,
+          transpileFormat,
+          transpileSplitting,
+          transpileMinify,
+          transpileSourcemap,
+          transpilePublicPath,
+          transpileStub,
+          transpileWatch,
+          timer,
+          coreDeclarations
+        )
+      ];
+      await pAll(buildTasks, { concurrency: CONCURRENCY_DEFAULT });
+      if (!isDev) {
+        const publishTasks = [
+          () => regular_pubToJsr(
+            distJsrDryRun,
+            distJsrFailOnWarn,
+            isDev,
+            commonPubPause,
+            distJsrDirName,
+            distJsrAllowDirty,
+            distJsrSlowTypes,
+            timer
+          ),
+          () => regular_pubToNpm(
+            distJsrDryRun,
+            isDev,
+            commonPubPause,
+            distNpmDirName,
+            timer
+          )
+        ];
+        await pAll(publishTasks, { concurrency: CONCURRENCY_DEFAULT });
+      }
+      break;
+    }
+    default: {
+      relinka(
+        "warn",
+        `Registry "${commonPubRegistry}" not recognized. Building main project only...`
+      );
+      const fallbackBuildTasks = [
+        () => regular_buildNpmDist(
+          isDev,
+          coreEntrySrcDir,
+          distNpmDirName,
+          distNpmBuilder,
+          coreEntryFile,
+          unifiedBundlerOutExt,
+          rmDepsMode,
+          coreIsCLI,
+          transpileTarget,
+          transpileFormat,
+          transpileSplitting,
+          transpileMinify,
+          transpileSourcemap,
+          transpilePublicPath,
+          transpileStub,
+          transpileWatch,
+          timer,
+          coreDeclarations
+        ),
+        () => regular_buildJsrDist(
+          isDev,
+          true,
+          coreIsCLI,
+          coreEntrySrcDir,
+          distJsrDirName,
+          distJsrBuilder,
+          coreEntryFile,
+          transpileTarget,
+          transpileFormat,
+          transpileSplitting,
+          transpileMinify,
+          transpileSourcemap,
+          transpilePublicPath,
+          unifiedBundlerOutExt,
+          rmDepsMode,
+          timer,
+          transpileStub,
+          transpileWatch,
+          distJsrGenTsconfig,
+          coreDeclarations
+        )
+      ];
+      await pAll(fallbackBuildTasks, { concurrency: CONCURRENCY_DEFAULT });
+    }
+  }
+}

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

@@ -0,0 +1,307 @@
+import path from "pathe";
+import * as fs from "./spells-filesystem.js";
+export const replaceLineExecutor = async (spell, filePath, content) => {
+  if (!spell.lineNumber) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: "Line number not provided"
+    };
+  }
+  if (!spell.value) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: "Target file not specified"
+    };
+  }
+  const includeFilePath = path.resolve(path.dirname(filePath), spell.value);
+  try {
+    const includeContent = await fs.readFile(includeFilePath);
+    const lines = content.split("\n");
+    const originalLine = lines[spell.lineNumber - 1];
+    lines[spell.lineNumber - 1] = includeContent.trim();
+    const newContent = lines.join("\n");
+    await fs.writeFile(filePath, newContent);
+    return {
+      spell,
+      file: filePath,
+      success: true,
+      message: `Line replaced with content from ${includeFilePath}`,
+      changes: {
+        before: originalLine ?? "",
+        after: includeContent.trim()
+      }
+    };
+  } catch (error) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: `Failed to replace line: ${error}`
+    };
+  }
+};
+export const renameFileExecutor = async (spell, filePath) => {
+  if (!spell.value) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: "New filename not provided"
+    };
+  }
+  const newPath = path.resolve(path.dirname(filePath), spell.value);
+  try {
+    await fs.renameFile(filePath, newPath);
+    return {
+      spell,
+      file: filePath,
+      success: true,
+      message: `File renamed to ${newPath}`
+    };
+  } catch (error) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: `Failed to rename file: ${error}`
+    };
+  }
+};
+export const removeCommentExecutor = async (spell, filePath, content) => {
+  if (!spell.lineNumber || !spell.fullMatch) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: "Line number or full match not provided"
+    };
+  }
+  try {
+    const lines = content.split("\n");
+    const originalLine = lines[spell.lineNumber - 1];
+    lines[spell.lineNumber - 1] = (originalLine ?? "").replace(spell.fullMatch, "").trim();
+    const newContent = lines.join("\n");
+    await fs.writeFile(filePath, newContent);
+    return {
+      spell,
+      file: filePath,
+      success: true,
+      message: "Comment removed",
+      changes: {
+        before: originalLine ?? "",
+        after: lines[spell.lineNumber - 1] ?? ""
+      }
+    };
+  } catch (error) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: `Failed to remove comment: ${error}`
+    };
+  }
+};
+export const removeLineExecutor = async (spell, filePath, content) => {
+  if (!spell.lineNumber) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: "Line number not provided"
+    };
+  }
+  try {
+    const lines = content.split("\n");
+    const originalLine = lines[spell.lineNumber - 1];
+    lines.splice(spell.lineNumber - 1, 1);
+    const newContent = lines.join("\n");
+    await fs.writeFile(filePath, newContent);
+    return {
+      spell,
+      file: filePath,
+      success: true,
+      message: "Line removed",
+      changes: {
+        before: originalLine ?? "",
+        after: ""
+      }
+    };
+  } catch (error) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: `Failed to remove line: ${error}`
+    };
+  }
+};
+export const removeFileExecutor = async (spell, filePath) => {
+  try {
+    await fs.removeFile(filePath);
+    return {
+      spell,
+      file: filePath,
+      success: true,
+      message: "File removed"
+    };
+  } catch (error) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: `Failed to remove file: ${error}`
+    };
+  }
+};
+export const copyFileExecutor = async (spell, filePath) => {
+  if (!spell.value) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: "Target path not provided"
+    };
+  }
+  const targetPath = path.resolve(path.dirname(filePath), spell.value);
+  try {
+    await fs.copyFile(filePath, targetPath);
+    return {
+      spell,
+      file: filePath,
+      success: true,
+      message: `File copied to ${targetPath}`
+    };
+  } catch (error) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: `Failed to copy file: ${error}`
+    };
+  }
+};
+export const moveFileExecutor = async (spell, filePath) => {
+  if (!spell.value) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: "Target path not provided"
+    };
+  }
+  const targetPath = path.resolve(path.dirname(filePath), spell.value);
+  try {
+    await fs.renameFile(filePath, targetPath);
+    return {
+      spell,
+      file: filePath,
+      success: true,
+      message: `File moved to ${targetPath}`
+    };
+  } catch (error) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: `Failed to move file: ${error}`
+    };
+  }
+};
+export const transformContentExecutor = async (spell, filePath, content) => {
+  if (!spell.value) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: "Transform function not provided"
+    };
+  }
+  try {
+    let newContent = content;
+    switch (spell.value) {
+      case "trim-empty-lines":
+        newContent = content.split("\n").filter((line) => line.trim() !== "").join("\n");
+        break;
+      case "normalize-imports":
+        newContent = content.replace(
+          /import\s+{([^}]+)}\s+from\s+['"]([^'"]+)['"]/g,
+          (_, imports, source) => {
+            const normalizedImports = imports.split(",").map((i) => i.trim()).sort().join(", ");
+            return `import { ${normalizedImports} } from "${source}"`;
+          }
+        );
+        break;
+      default:
+        return {
+          spell,
+          file: filePath,
+          success: false,
+          message: `Unknown transformation: ${spell.value}`
+        };
+    }
+    await fs.writeFile(filePath, newContent);
+    return {
+      spell,
+      file: filePath,
+      success: true,
+      message: `Content transformed with ${spell.value}`,
+      changes: {
+        before: content,
+        after: newContent
+      }
+    };
+  } catch (error) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: `Failed to transform content: ${error}`
+    };
+  }
+};
+export const insertAtExecutor = async (spell, filePath, content) => {
+  if (!spell.value || !spell.params.content) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: "Position or content not provided"
+    };
+  }
+  try {
+    const lines = content.split("\n");
+    const position = Number(spell.value);
+    if (Number.isNaN(position) || position < 0 || position > lines.length) {
+      return {
+        spell,
+        file: filePath,
+        success: false,
+        message: `Invalid position: ${spell.value}`
+      };
+    }
+    lines.splice(position, 0, spell.params.content);
+    const newContent = lines.join("\n");
+    await fs.writeFile(filePath, newContent);
+    return {
+      spell,
+      file: filePath,
+      success: true,
+      message: `Content inserted at position ${position}`,
+      changes: {
+        before: content,
+        after: newContent
+      }
+    };
+  } catch (error) {
+    return {
+      spell,
+      file: filePath,
+      success: false,
+      message: `Failed to insert content: ${error}`
+    };
+  }
+};

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

@@ -0,0 +1,72 @@
+import fs from "fs-extra";
+import path from "pathe";
+export const fileExists = async (filePath) => {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+};
+export const readFile = async (filePath) => {
+  return await fs.readFile(filePath, "utf-8");
+};
+export const writeFile = async (filePath, content) => {
+  const dir = path.dirname(filePath);
+  try {
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(filePath, content, "utf-8");
+  } catch (error) {
+    throw new Error(`Failed to write file ${filePath}: ${error}`);
+  }
+};
+export const removeFile = async (filePath) => {
+  try {
+    await fs.unlink(filePath);
+  } catch (error) {
+    throw new Error(`Failed to remove file ${filePath}: ${error}`);
+  }
+};
+export const renameFile = async (oldPath, newPath) => {
+  try {
+    const dir = path.dirname(newPath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.rename(oldPath, newPath);
+  } catch (error) {
+    throw new Error(`Failed to rename file ${oldPath} to ${newPath}: ${error}`);
+  }
+};
+export const copyFile = async (sourcePath, targetPath) => {
+  try {
+    const dir = path.dirname(targetPath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.copyFile(sourcePath, targetPath);
+  } catch (error) {
+    throw new Error(
+      `Failed to copy file ${sourcePath} to ${targetPath}: ${error}`
+    );
+  }
+};
+export const findFiles = async (patterns, cwd = process.cwd()) => {
+  const results = [];
+  const scanDir = async (dir) => {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await scanDir(fullPath);
+      } else if (matchesAnyPattern(fullPath, patterns)) {
+        results.push(fullPath);
+      }
+    }
+  };
+  await scanDir(cwd);
+  return results;
+};
+const matchesAnyPattern = (filePath, patterns) => {
+  if (patterns.length === 0) return true;
+  return patterns.some((pattern) => {
+    if (pattern === "*") return true;
+    return filePath.includes(pattern);
+  });
+};

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

@@ -0,0 +1,87 @@
+import * as executors from "./spells-executors.js";
+import * as fs from "./spells-filesystem.js";
+import { extractSpellsFromFile } from "./spells-parser.js";
+export const executeSpell = async (spell, filePath, content) => {
+  if (spell.params.hooked) {
+    return {
+      spell,
+      file: filePath,
+      success: true,
+      message: "Skipped (hooked=true)"
+    };
+  }
+  switch (spell.type) {
+    case "replace-line":
+      return await executors.replaceLineExecutor(spell, filePath, content);
+    case "rename-file":
+      return await executors.renameFileExecutor(spell, filePath);
+    case "remove-comment":
+      return await executors.removeCommentExecutor(spell, filePath, content);
+    case "remove-line":
+      return await executors.removeLineExecutor(spell, filePath, content);
+    case "remove-file":
+      return await executors.removeFileExecutor(spell, filePath);
+    case "transform-content":
+      return await executors.transformContentExecutor(spell, filePath, content);
+    case "copy-file":
+      return await executors.copyFileExecutor(spell, filePath);
+    case "move-file":
+      return await executors.moveFileExecutor(spell, filePath);
+    case "insert-at":
+      return await executors.insertAtExecutor(spell, filePath, content);
+    default:
+      return {
+        spell,
+        file: filePath,
+        success: false,
+        message: `Unknown spell type: ${spell.type}`
+      };
+  }
+};
+export const processFile = async (filePath, options = {}) => {
+  const results = [];
+  try {
+    const content = await fs.readFile(filePath);
+    const spells2 = await extractSpellsFromFile(filePath, content);
+    for (const spell of spells2) {
+      if (options.spells && options.spells.length > 0 && !options.spells.includes("all") && !options.spells.includes(spell.type)) {
+        continue;
+      }
+      const result = await executeSpell(spell, filePath, content);
+      results.push(result);
+      if (result.success && (spell.type === "remove-file" || spell.type === "rename-file")) {
+        break;
+      }
+    }
+    return results;
+  } catch (error) {
+    return [
+      {
+        spell: { type: "unknown", params: { hooked: false } },
+        file: filePath,
+        success: false,
+        message: `Failed to process file: ${error}`
+      }
+    ];
+  }
+};
+export const spells = async (options = {}) => {
+  const results = [];
+  try {
+    const filesToProcess = options.files?.length ? options.files : await fs.findFiles(["*"], process.cwd());
+    for (const filePath of filesToProcess) {
+      const fileResults = await processFile(filePath, options);
+      results.push(...fileResults);
+    }
+    return results;
+  } catch (error) {
+    return [
+      {
+        spell: { type: "unknown", params: { hooked: false } },
+        file: "unknown",
+        success: false,
+        message: `Failed to trigger spells: ${error}`
+      }
+    ];
+  }
+};