@reliverse/dler 1.5.5 → 1.5.7

package/README.md

@@ -127,7 +127,7 @@ if you run just `dler` — it will display a list of plugins which you can launc
 
 ## **available plugins**
 
-[agg](#1-agg), [build](#2-build), [conv](#3-conv), [deps](#4-deps), [inject](#5-inject), [libs](#6-libs), [merge](#7-merge), [mono](#8-mono), [pub](#9-pub), [relifso](#10-relifso), [relinka](#11-relinka), [rempts](#12-rempts), [spell](#13-spell), [split](#14-split).
+[agg](#1-agg), [build](#2-build), [conv](#3-conv), [deps](#4-deps), [inject](#5-inject), [libs](#6-libs), [merge](#7-merge), [migrate](#8-migrate), [mono](#9-mono), [pub](#10-pub), [relifso](#11-relifso), [relinka](#12-relinka), [rempts](#13-rempts), [spell](#14-spell), [split](#15-split).
 
 ### 1. `agg`
 
@@ -253,11 +253,61 @@ libslist: {
 
 not yet documented.
 
-### 8. `mono`
+### 8. `migrate`
+
+helps migrate between different libraries and module resolution strategies. currently supports:
+
+- `pathe-to-pathkit`: migrate from pathe to pathkit library
+- `pathkit-to-pathe`: migrate from pathkit to pathe library
+- `module-resolution`: migrate between module resolution strategies
+
+**module resolution targets:**
+
+- `nodenext`: adds `.js` extensions to imports and updates tsconfig
+- `bundler`: removes extensions from imports and updates tsconfig
+
+**usage examples:**
+
+```bash
+# Migrate from pathe to pathkit
+dler migrate --lib pathe-to-pathkit
+
+# Migrate to nodenext module resolution
+dler migrate --lib module-resolution --target nodenext
+
+# Migrate to bundler module resolution
+dler migrate --lib module-resolution --target bundler
+
+# Preview changes without applying them
+dler migrate --lib module-resolution --target nodenext --dryRun
+```
+
+**what it does:**
+
+- updates import statements in your code
+- modifies tsconfig.json settings
+- updates package.json type field
+- provides a dry run option to preview changes
+- handles both relative and alias imports
+- supports both .ts and .tsx files
+
+**next steps after migration:**
+
+- for pathe-to-pathkit:
+  1. run 'bun install' to install @reliverse/pathkit
+  2. test your application
+  3. consider using advanced pathkit features
+
+- for module-resolution:
+  1. test your application
+  2. ensure your build tools support the new module resolution
+  3. review any warnings in the migration output
+
+### 9. `mono`
 
 not yet documented.
 
-### 9. `pub`
+### 10. `pub`
 
 pub command is separated for its own build-in plugin as well.
 
@@ -267,13 +317,13 @@ it already calls build command by itself, so you don't need to run `dler build`
 dler pub ...
 ```
 
-### 10. `relifso`
+### 11. `relifso`
 
 ```bash
 dler relifso init ...
 ```
 
-### 11. `relinka`
+### 12. `relinka`
 
 @reliverse/relinka's best friend. learn more in its [docs](https://github.com/reliverse/relinka).
 
@@ -281,7 +331,7 @@ dler relifso init ...
 dler relinka --console-to-relinka
 ```
 
-### 12. `rempts`
+### 13. `rempts`
 
 @reliverse/rempts's best friend. learn more in its [docs](https://github.com/reliverse/rempts).
 
@@ -290,47 +340,58 @@ dler rempts init --cmd my-cmd-1
 dler rempts init --cmds
 ```
 
-### 13. `spell`
+### 14. `spell`
 
 **available spell types:**
 
 - `replace-line` — injects contents from one file into another
+- `replace-range` — replaces a range of lines with content from another file
 - `rename-file` — renames the current file
 - `remove-comment` — removes a specific comment from code
 - `remove-line` — removes a specific line from code
 - `remove-file` — deletes the current file
 - `transform-content` — applies a transformation to the file content
+- `transform-line` — applies a transformation to a specific line
 - `copy-file` — copies the current file to a new location
 - `move-file` — moves the current file to a new location
 - `insert-at` — inserts content at a specific position in the file
+- `insert-before` — inserts content before a specific line
+- `insert-after` — inserts content after a specific line
+- `conditional-execute` — executes spells conditionally
 
 **params:**
 
 params are optional and comma-separated.
 
-currently, only the first param is supported:
-
-- `hooked` (boolean, default: `false`)  
-  - `false`: dler handles the spell automatically at postbuild  
+- `hooked` (boolean, default: `true`)  
   - `true`: disables default behavior, so you can trigger the spell yourself (e.g. from your own cli function)
-
-more params coming soon...
+  - `false`: dler handles the spell automatically at postbuild
+- `startLine` (number) — line number to start the operation (for range operations)
+- `endLine` (number) — line number to end the operation (for range operations)
+- `condition` (string) — condition to check before executing the spell
+- `skipIfMissing` (boolean) — whether to skip the spell if the target file doesn't exist
+- `createDir` (boolean) — whether to create the target directory if it doesn't exist
 
 **usage examples:**
 
-- `export * from "../../types.js"; // <dler-replace-line-{hooked=false}>` — injects file contents at this line
-- `// @ts-expect-error <dler-remove-comment-{hooked=false}>` — removes just this comment
-- `// <dler-remove-line-{hooked=false}>` — removes this line
-- `// <dler-remove-file-{hooked=false}>` — deletes this file
-- `// <dler-rename-file-"tsconfig.json"-{hooked=false}>` — renames this file (runs at postbuild because `hooked=false`)
+- `export * from "../../types.js"; // dler-replace-line` — injects file contents at this line (hooked=true by default)
+- `// @ts-expect-error dler-remove-comment` — removes just this comment (hooked=true by default)
+- `// dler-remove-line` — removes this line (hooked=true by default)
+- `// dler-remove-file` — deletes this file (hooked=true by default)
+- `// dler-rename-file-"tsconfig.json"-{hooked=false}` — renames this file (runs at postbuild because `hooked=false`)
+- `// dler-replace-range-"../../types.js"-{startLine=1,endLine=5}` — replaces lines 1-5 with content from types.js
+- `// dler-transform-line-"return line.toUpperCase()"` — transforms the line to uppercase
+- `// dler-insert-before-"import { x } from 'y';"` — inserts import statement before this line
+- `// dler-insert-after-"export { x };"` — inserts export statement after this line
+- `// dler-conditional-execute-{condition="content.includes('TODO')"}` — executes spells only if file contains TODO
 
-**using `hooked=true`:**
+**using `hooked=false`:**
 
-- `// <dler-rename-file-"tsconfig.json"-{hooked=true}>` — renames the file, but only when you trigger it yourself (hooked from your side)
+- `// dler-rename-file-"tsconfig.json"-{hooked=false}` — renames the file immediately at postbuild (not hooked)
 
 **triggering spells:**
 
-from dler’s cli:  
+from dler's cli:  
 
 - `dler spell --trigger rename-file,... --files tsconfig.json,...`
 - `dler spell --trigger all`
@@ -340,15 +401,15 @@ from your own code:
 
 ```ts
 await dler.spell({ spells: ["rename-file"], files: [] });
-// await dler.spell({}) // means all spells and all files
-// spell: ["all"] // means all spells
-// spell: [] // means all spells
-// files: [] // means all files
+await dler.spell({}) // all spells, all files
+spells: ["all"] // means all spells
+spells: [] // also means all spells
+files: [] // means all files
 ```
 
 p.s. [see how rse cli uses hooked=true](https://github.com/reliverse/rse/blob/main/src/postbuild.ts)
 
-### 14. `split`
+### 15. `split`
 
 splits your code/text file into multiple files.
 

package/bin/app/cmds.d.ts

@@ -195,3 +195,19 @@ export declare function cmdRelifsoRename(): Promise<import("@reliverse/rempts").
         default: false;
     };
 }>>;
+export declare function cmdMigrate(): Promise<import("@reliverse/rempts").Command<{
+    lib: {
+        type: "string";
+        description: string;
+    };
+    target: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    dryRun: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>>;

package/bin/app/cmds.js

@@ -16,3 +16,6 @@ export async function cmdPub() {
 export async function cmdRelifsoRename() {
   return (await import("./relifso/rename/cmd.js")).default;
 }
+export async function cmdMigrate() {
+  return (await import("./migrate/cmd.js")).default;
+}

package/bin/app/deps/impl/analyzer.d.ts

@@ -1,2 +1,2 @@
-import type { DependencyResult, FinderOptions } from "./deps-types.js";
+import type { DependencyResult, FinderOptions } from "./deps-types";
 export declare const analyzeDependencies: (options: FinderOptions) => Promise<DependencyResult>;

package/bin/app/deps/impl/filesystem.d.ts

@@ -1,4 +1,4 @@
-import type { PackageJson } from "./deps-types.js";
+import type { PackageJson } from "./deps-types";
 export declare const findSourceFiles: (directory: string, ignorePatterns: string[]) => Promise<string[]>;
 export declare const readFile: (filePath: string) => Promise<string>;
 export declare const readPackageJson: (directory: string) => Promise<PackageJson>;

package/bin/app/deps/impl/formatter.d.ts

@@ -1,2 +1,2 @@
-import type { DependencyResult, FinderOptions } from "./deps-types.js";
+import type { DependencyResult, FinderOptions } from "./deps-types";
 export declare const formatOutput: (result: DependencyResult, options: FinderOptions) => string;

package/bin/app/deps/impl/parser.d.ts

@@ -1,4 +1,4 @@
-import type { PackageJson } from "./deps-types.js";
+import type { PackageJson } from "./deps-types";
 export declare const extractPackageNames: (fileContent: string) => Set<string>;
 export declare const normalizePackageName: (importPath: string) => string | null;
 export declare const getListedDependencies: (packageJson: PackageJson) => Set<string>;

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

@@ -0,0 +1,17 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    lib: {
+        type: "string";
+        description: string;
+    };
+    target: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    dryRun: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+export default _default;

package/bin/app/migrate/cmd.js

@@ -0,0 +1,121 @@
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import {
+  migratePatheToPathkit,
+  migratePathkitToPathe
+} from "./codemods/lib-pathe-pathkit.js";
+import { migrateModuleResolution } from "./codemods/ts-module-resolution.js";
+export default defineCommand({
+  meta: {
+    name: "migrate",
+    version: "1.0.0",
+    description: "Migrate between different libraries and usages"
+  },
+  args: defineArgs({
+    lib: {
+      type: "string",
+      description: "The migration to perform (pathe-to-pathkit | pathkit-to-pathe | module-resolution)"
+    },
+    target: {
+      type: "string",
+      description: "Target for module resolution migration (nodenext | bundler)",
+      default: "nodenext"
+    },
+    dryRun: {
+      type: "boolean",
+      description: "Preview changes without applying them",
+      default: false
+    }
+  }),
+  async run({ args }) {
+    let results = [];
+    if (args.lib === "pathe-to-pathkit") {
+      console.log("Migrating from pathe to pathkit...");
+      results = await migratePatheToPathkit(args.dryRun);
+    } else if (args.lib === "pathkit-to-pathe") {
+      console.log("Migrating from pathkit to pathe...");
+      results = await migratePathkitToPathe(args.dryRun);
+    } else if (args.lib === "module-resolution") {
+      if (!["nodenext", "bundler"].includes(args.target)) {
+        console.error(`Invalid target: ${args.target}`);
+        console.log("Available targets:");
+        console.log("  - nodenext");
+        console.log("  - bundler");
+        return;
+      }
+      console.log(`Migrating to ${args.target} module resolution...`);
+      results = await migrateModuleResolution(
+        args.target,
+        args.dryRun
+      );
+    } else {
+      console.error(`Unknown migration: ${args.lib}`);
+      console.log("Available migrations:");
+      console.log("  - pathe-to-pathkit");
+      console.log("  - pathkit-to-pathe");
+      console.log("  - module-resolution");
+      return;
+    }
+    console.log("\nMigration Results:");
+    let successCount = 0;
+    let errorCount = 0;
+    let warningCount = 0;
+    for (const result of results) {
+      const status = result.success ? "\u2713" : "\u2717";
+      console.log(`${status} ${result.file}: ${result.message}`);
+      if (result.changes && result.changes.length > 0) {
+        for (const change of result.changes) {
+          if (change.startsWith("\u26A0\uFE0F")) {
+            console.log(`    ${change}`);
+            warningCount++;
+          } else {
+            console.log(`    - ${change}`);
+          }
+        }
+      }
+      if (result.success) successCount++;
+      else errorCount++;
+    }
+    console.log(
+      `
+Summary: ${successCount} files updated, ${errorCount} errors, ${warningCount} warnings`
+    );
+    if (args.dryRun) {
+      console.log("\nThis was a dry run. No changes were made.");
+      console.log("Run without --dryRun to apply the changes.");
+    } else {
+      console.log("\nMigration completed!");
+      if (args.lib === "pathe-to-pathkit") {
+        console.log("Next steps:");
+        console.log("1. Run 'bun install' to install @reliverse/pathkit");
+        console.log("2. Test your application");
+        console.log(
+          "3. Consider using advanced pathkit features like alias resolution"
+        );
+      } else if (args.lib === "pathkit-to-pathe") {
+        console.log("Next steps:");
+        console.log("1. Run 'bun install' to install pathe");
+        console.log("2. Test your application");
+        if (warningCount > 0) {
+          console.log(
+            "3. \u26A0\uFE0F  Review files with warnings - they may need manual updates"
+          );
+        }
+      } else if (args.lib === "module-resolution") {
+        console.log("Next steps:");
+        console.log("1. Test your application");
+        if (args.target === "nodenext") {
+          console.log(
+            "2. Ensure your build tools support .js extensions in imports"
+          );
+        } else if (args.target === "bundler") {
+          console.log("2. Ensure your bundler is configured correctly");
+        }
+        if (warningCount > 0) {
+          console.log(
+            "3. \u26A0\uFE0F  Review files with warnings - they may need manual updates"
+          );
+        }
+      }
+    }
+  }
+});

package/bin/app/migrate/codemods/lib-pathe-pathkit.d.ts

@@ -0,0 +1,9 @@
+type MigrationResult = {
+    file: string;
+    success: boolean;
+    message: string;
+    changes?: string[];
+};
+export declare function migratePatheToPathkit(dryRun?: boolean): Promise<MigrationResult[]>;
+export declare function migratePathkitToPathe(dryRun?: boolean): Promise<MigrationResult[]>;
+export {};

package/bin/app/migrate/codemods/lib-pathe-pathkit.js

@@ -0,0 +1,258 @@
+import { existsSync } from "node:fs";
+import { readFile, writeFile, readdir, stat } from "node:fs/promises";
+import { join, extname } from "node:path";
+async function getAllTsFiles(dir) {
+  const files = [];
+  try {
+    const entries = await readdir(dir);
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
+      const stats = await stat(fullPath);
+      if (stats.isDirectory() && !entry.startsWith(".") && entry !== "node_modules") {
+        const subFiles = await getAllTsFiles(fullPath);
+        files.push(...subFiles);
+      } else if (stats.isFile()) {
+        const ext = extname(entry);
+        if ([".ts", ".tsx", ".js", ".jsx", ".vue", ".svelte"].includes(ext)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+export async function migratePatheToPathkit(dryRun = false) {
+  const results = [];
+  const files = await getAllTsFiles(".");
+  for (const file of files) {
+    try {
+      const content = await readFile(file, "utf-8");
+      let modified = content;
+      const changes = [];
+      const patheImportRegex = /from\s+["']pathe["']/g;
+      if (patheImportRegex.test(content)) {
+        modified = modified.replace(
+          patheImportRegex,
+          'from "@reliverse/pathkit"'
+        );
+        changes.push("Updated pathe imports to @reliverse/pathkit");
+      }
+      const patheUtilsRegex = /from\s+["']pathe\/utils["']/g;
+      if (patheUtilsRegex.test(content)) {
+        modified = modified.replace(
+          patheUtilsRegex,
+          'from "@reliverse/pathkit"'
+        );
+        changes.push("Updated pathe/utils imports to @reliverse/pathkit");
+      }
+      const patheRequireRegex = /require\s*\(\s*["']pathe["']\s*\)/g;
+      if (patheRequireRegex.test(content)) {
+        modified = modified.replace(
+          patheRequireRegex,
+          'require("@reliverse/pathkit")'
+        );
+        changes.push("Updated pathe require to @reliverse/pathkit");
+      }
+      const patheUtilsRequireRegex = /require\s*\(\s*["']pathe\/utils["']\s*\)/g;
+      if (patheUtilsRequireRegex.test(content)) {
+        modified = modified.replace(
+          patheUtilsRequireRegex,
+          'require("@reliverse/pathkit")'
+        );
+        changes.push("Updated pathe/utils require to @reliverse/pathkit");
+      }
+      if (changes.length > 0) {
+        if (!dryRun) {
+          await writeFile(file, modified, "utf-8");
+        }
+        results.push({
+          file,
+          success: true,
+          message: `${changes.length} change(s) made`,
+          changes
+        });
+      }
+    } catch (error) {
+      results.push({
+        file,
+        success: false,
+        message: `Failed to process: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  }
+  await updatePackageJson(results, dryRun, {
+    remove: ["pathe"],
+    add: { "@reliverse/pathkit": "^latest" }
+  });
+  return results;
+}
+export async function migratePathkitToPathe(dryRun = false) {
+  const results = [];
+  const files = await getAllTsFiles(".");
+  for (const file of files) {
+    try {
+      const content = await readFile(file, "utf-8");
+      let modified = content;
+      const changes = [];
+      const pathkitImportRegex = /from\s+["']@reliverse\/pathkit["']/g;
+      if (pathkitImportRegex.test(content)) {
+        const advancedFeatures = [
+          "getFileImportsExports",
+          "convertImportPaths",
+          "convertImportExtensionsJsToTs",
+          "normalizeAliases",
+          "resolveAlias",
+          "reverseResolveAlias",
+          "normalizeQuotes"
+        ];
+        const usesAdvancedFeatures = advancedFeatures.some(
+          (feature) => content.includes(feature)
+        );
+        if (usesAdvancedFeatures) {
+          changes.push(
+            "\u26A0\uFE0F  File uses advanced pathkit features - manual review needed"
+          );
+          results.push({
+            file,
+            success: false,
+            message: "Contains advanced pathkit features not available in pathe",
+            changes
+          });
+          continue;
+        }
+        const utilsPattern = /import\s*\{([^}]+)\}\s*from\s*["']@reliverse\/pathkit["']/g;
+        const utilsMatch = utilsPattern.exec(content);
+        if (utilsMatch?.[1]) {
+          const imports = utilsMatch[1].split(",").map((s) => s.trim());
+          const coreImports = imports.filter(
+            (imp) => ![
+              "filename",
+              "normalizeAliases",
+              "resolveAlias",
+              "reverseResolveAlias"
+            ].includes(imp.replace(/\s+as\s+\w+/, ""))
+          );
+          const utilImports = imports.filter(
+            (imp) => [
+              "filename",
+              "normalizeAliases",
+              "resolveAlias",
+              "reverseResolveAlias"
+            ].includes(imp.replace(/\s+as\s+\w+/, ""))
+          );
+          if (coreImports.length > 0 && utilImports.length > 0) {
+            const coreImportStatement = `import { ${coreImports.join(", ")} } from "pathe";`;
+            const utilImportStatement = `import { ${utilImports.join(", ")} } from "pathe/utils";`;
+            modified = modified.replace(
+              utilsMatch[0],
+              `${coreImportStatement}
+${utilImportStatement}`
+            );
+            changes.push(
+              "Split pathkit imports into pathe core and pathe/utils"
+            );
+          } else if (utilImports.length > 0) {
+            modified = modified.replace(
+              pathkitImportRegex,
+              'from "pathe/utils"'
+            );
+            changes.push("Updated pathkit utils imports to pathe/utils");
+          } else {
+            modified = modified.replace(pathkitImportRegex, 'from "pathe"');
+            changes.push("Updated pathkit imports to pathe");
+          }
+        } else {
+          modified = modified.replace(pathkitImportRegex, 'from "pathe"');
+          changes.push("Updated pathkit imports to pathe");
+        }
+      }
+      const pathkitRequireRegex = /require\s*\(\s*["']@reliverse\/pathkit["']\s*\)/g;
+      if (pathkitRequireRegex.test(content)) {
+        modified = modified.replace(pathkitRequireRegex, 'require("pathe")');
+        changes.push("Updated pathkit require to pathe");
+      }
+      if (changes.length > 0) {
+        if (!dryRun) {
+          await writeFile(file, modified, "utf-8");
+        }
+        results.push({
+          file,
+          success: true,
+          message: `${changes.length} change(s) made`,
+          changes
+        });
+      }
+    } catch (error) {
+      results.push({
+        file,
+        success: false,
+        message: `Failed to process: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  }
+  await updatePackageJson(results, dryRun, {
+    remove: ["@reliverse/pathkit"],
+    add: { pathe: "^latest" }
+  });
+  return results;
+}
+async function updatePackageJson(results, dryRun, config) {
+  try {
+    const packageJsonPath = "./package.json";
+    if (existsSync(packageJsonPath)) {
+      const packageContent = await readFile(packageJsonPath, "utf-8");
+      const packageJson = JSON.parse(packageContent);
+      let packageChanged = false;
+      const packageChanges = [];
+      for (const pkg of config.remove) {
+        if (packageJson.dependencies?.[pkg]) {
+          packageJson.dependencies = Object.fromEntries(
+            Object.entries(packageJson.dependencies).filter(
+              ([key]) => key !== pkg
+            )
+          );
+          packageChanged = true;
+          packageChanges.push(`Removed ${pkg} from dependencies`);
+        }
+        if (packageJson.devDependencies?.[pkg]) {
+          packageJson.devDependencies = Object.fromEntries(
+            Object.entries(packageJson.devDependencies).filter(
+              ([key]) => key !== pkg
+            )
+          );
+          packageChanged = true;
+          packageChanges.push(`Removed ${pkg} from devDependencies`);
+        }
+      }
+      for (const [pkg, version] of Object.entries(config.add)) {
+        if (packageChanged && !packageJson.dependencies?.[pkg]) {
+          if (!packageJson.dependencies) packageJson.dependencies = {};
+          packageJson.dependencies[pkg] = version;
+          packageChanges.push(`Added ${pkg} to dependencies`);
+        }
+      }
+      if (packageChanged) {
+        if (!dryRun) {
+          await writeFile(
+            packageJsonPath,
+            JSON.stringify(packageJson, null, 2) + "\n",
+            "utf-8"
+          );
+        }
+        results.push({
+          file: packageJsonPath,
+          success: true,
+          message: `${packageChanges.length} change(s) made`,
+          changes: packageChanges
+        });
+      }
+    }
+  } catch (error) {
+    results.push({
+      file: "./package.json",
+      success: false,
+      message: `Failed to update package.json: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+}

package/bin/app/migrate/codemods/ts-module-resolution.d.ts

@@ -0,0 +1,10 @@
+type MigrationResult = {
+    file: string;
+    success: boolean;
+    message: string;
+    changes?: string[];
+};
+export declare function migrateToNodeNext(dryRun?: boolean): Promise<MigrationResult[]>;
+export declare function migrateToBundler(dryRun?: boolean): Promise<MigrationResult[]>;
+export declare function migrateModuleResolution(target: "nodenext" | "bundler", dryRun?: boolean): Promise<MigrationResult[]>;
+export {};