@reliverse/dler 1.7.15 → 1.7.17

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

@@ -1,307 +0,0 @@
-import path from "@reliverse/pathkit";
-import * as fs from "./spell-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, true);
-    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/spell/spell-filesystem.d.ts

@@ -1,7 +0,0 @@
-export declare const fileExists: (filePath: string) => Promise<boolean>;
-export declare const readFile: (filePath: string) => Promise<string>;
-export declare const writeFile: (filePath: string, content: string) => Promise<void>;
-export declare const removeFile: (filePath: string) => Promise<void>;
-export declare const renameFile: (oldPath: string, newPath: string) => Promise<void>;
-export declare const copyFile: (sourcePath: string, targetPath: string, overwrite?: boolean) => Promise<void>;
-export declare const findFiles: (patterns: string[], cwd?: string) => Promise<string[]>;

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

@@ -1,74 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-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, "utf8");
-};
-export const writeFile = async (filePath, content) => {
-  const dir = path.dirname(filePath);
-  try {
-    await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(filePath, content, "utf8");
-  } 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, overwrite = true) => {
-  try {
-    const dir = path.dirname(targetPath);
-    await fs.mkdir(dir, { recursive: true });
-    const exists = await fileExists(targetPath);
-    if (exists && !overwrite) {
-      throw new Error(`Destination ${targetPath} already exists and overwrite is false.`);
-    }
-    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/spell/spell-mod.d.ts

@@ -1,4 +0,0 @@
-import type { Spell, SpellExecutionOptions, SpellResult } from "./spell-types";
-export declare const executeSpell: (spell: Spell, filePath: string, content: string) => Promise<SpellResult>;
-export declare const processFile: (filePath: string, options?: SpellExecutionOptions) => Promise<SpellResult[]>;
-export declare const spells: (options?: SpellExecutionOptions) => Promise<SpellResult[]>;

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

@@ -1,87 +0,0 @@
-import * as executors from "./spell-executors.js";
-import * as fs from "./spell-filesystem.js";
-import { extractSpellsFromFile } from "./spell-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}`
-      }
-    ];
-  }
-};

package/bin/libs/sdk/sdk-impl/spell/spell-parser.d.ts

@@ -1,4 +0,0 @@
-import type { Spell, SpellParams } from "./spell-types.js";
-export declare const parseParams: (paramsStr: string | undefined) => SpellParams;
-export declare const parseSpellFromComment: (line: string, lineNumber: number, fileName: string) => Spell | null;
-export declare const extractSpellsFromFile: (filePath: string, content: string) => Promise<Spell[]>;

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

@@ -1,58 +0,0 @@
-const SPELL_REGEX = /dler-([a-z-]+)-(?:"([^"]+)")?-?(?:{([^}]+)})?/;
-export const parseParams = (paramsStr) => {
-  const defaultParams = {
-    hooked: true
-  };
-  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/spell/spell-types.d.ts

@@ -1,60 +0,0 @@
-export type SpellType = "replace-line" | "replace-range" | "rename-file" | "remove-comment" | "remove-line" | "remove-file" | "transform-content" | "transform-line" | "copy-file" | "move-file" | "insert-at" | "insert-before" | "insert-after" | "conditional-execute";
-export type SpellParams = {
-    /** Whether the spell should be executed manually (true) or automatically at postbuild (false) */
-    hooked: boolean;
-    /** Line number to start the operation (for range operations) */
-    startLine?: number;
-    /** Line number to end the operation (for range operations) */
-    endLine?: number;
-    /** Condition to check before executing the spell */
-    condition?: string;
-    /** Whether to skip the spell if the target file doesn't exist */
-    skipIfMissing?: boolean;
-    /** Whether to create the target directory if it doesn't exist */
-    createDir?: boolean;
-    /** Custom parameters for specific spell types */
-    [key: string]: any;
-};
-export type Spell = {
-    type: SpellType;
-    params: SpellParams;
-    value?: string;
-    lineNumber?: number;
-    fullMatch?: string;
-    fileName?: string;
-    /** Optional array of spells that must be executed before this one */
-    dependsOn?: Spell[];
-};
-export type SpellExecutionOptions = {
-    spells?: (SpellType | "all")[];
-    files?: string[];
-    dryRun?: boolean;
-    /** Whether to show detailed changes in the output */
-    showChanges?: boolean;
-    /** Whether to validate spell parameters before execution */
-    validate?: boolean;
-};
-export type FileOperation = {
-    type: "read" | "write" | "rename" | "remove" | "copy" | "move";
-    sourcePath: string;
-    targetPath?: string;
-    content?: string;
-    /** Whether to create parent directories if they don't exist */
-    createDir?: boolean;
-};
-export type SpellResult = {
-    spell: Spell;
-    file: string;
-    success: boolean;
-    message?: string;
-    changes?: {
-        before: string;
-        after: string;
-    };
-    /** Detailed information about the changes made */
-    details?: {
-        linesAffected?: number[];
-        filesAffected?: string[];
-        validationErrors?: string[];
-    };
-};