@reliverse/dler 1.2.2 → 1.2.4

package/README.md

@@ -1,12 +1,12 @@
 # dler (prev. relidler) • reliverse bundler
 
-[💖 github sponsors](https://github.com/sponsors/blefnk) — [💬 discord](https://discord.gg/pb8ukbwpsj) — [✨ repo](https://github.com/reliverse/dler) — [📦 npm](https://npmjs.com/@reliverse/dler) — [📚 docs](https://docs.reliverse.org/reliverse/dler)
+> @reliverse/dler (`/ˈdiː.lər/`, dealer) is a flexible, unified, and fully automated bundler for typescript and javascript projects, as well as an npm and jsr publishing tool. dler is not only a bundler, it also tries to serve as the most powerful codemod toolkit for js/ts.
 
-> @reliverse/dler (`/ˈdiː.lər/`, dealer) is a flexible, unified, and fully automated bundler for typescript and javascript projects, as well as an npm and jsr publishing tool.
+[sponsor](https://github.com/sponsors/blefnk) — [discord](https://discord.gg/pb8ukbwpsj) — [repo](https://github.com/reliverse/dler) — [npm](https://npmjs.com/@reliverse/dler) — [docs](https://docs.reliverse.org/reliverse/dler)
 
 ## features
 
-- 😘 replacement for `unbuild`
+- 😘 replacement for `unjs/unbuild`
 - ⚡ `dler` works via cli and sdk
 - 📦 automated npm/jsr publishing
 - ✅ ensures reliable js/ts builds
@@ -66,14 +66,6 @@ bun dev # bun src/mod.ts --dev
     bun update --latest
     ```
 
-    **or install globally**:
-
-    ```sh
-    bun i -g @reliverse/dler
-    # or update as needed:
-    bun -g update --latest
-    ```
-
 2. **prepare your project**:
 
     a. **configure `.gitignore`**:
@@ -122,77 +114,41 @@ bun dev # bun src/mod.ts --dev
     dler [build|pub] # if installed globally
     ```
 
-absolutely! here’s your improved section, now listing all available spell types:
-
----
-
 ## 🔌 plugins
 
-dler ships with a flexible plugin system and **10 built-in plugins** (from [@reliverse/addons](https://reliverse.org/addons)).
+dler ships with a flexible plugin system and **15 built-in plugins** (from [@reliverse/addons](https://reliverse.org/addons)).
 
-### 1. `magic-spells-dler-plugin`
-
-**available spell types:**
+feel free to create your own plugins. plugins can be implemented as built-in directly in `src/app/plugin-name/impl/*` and then imported from `src/app/plugin-name/cmd.ts`; or implemented in your own library and then imported from `src/app/plugin-name/cmd.ts`.
 
-- `replace-line` — injects contents from one file into another
-- `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
-- `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
+### 1. `agg`
 
-**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  
-  - `true`: disables default behavior, so you can trigger the spell yourself (e.g. from your own cli function)
-
-more params coming soon...
-
-**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`)
+generates aggregator file with content like `import { getsomething } from "./utils.js"`.
 
-**using `hooked=true`:**
+```bash
+dler agg ...
+```
 
-- `// <dler-rename-file-"tsconfig.json"-{hooked=true}>` — renames the file, but only when you trigger it yourself (hooked from your side)
+### 2. `auth`
 
-**triggering spells:**
+best friend of auth+db libs like [better-auth](https://better-auth.com) and [drizzle-orm](https://orm.drizzle.team).
 
-from dler’s cli:  
+```bash
+dler auth better-auth generate
+```
 
-- `dler spell --trigger rename-file,... --files tsconfig.json,...`
-- `dler spell --trigger all`
-- `dler spell`
+### 3. `build`
 
-from your own code:
+since dler is fully modular, build command is separated for its own build-in plugin as well.
 
-```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
+```bash
+dler build ...
 ```
 
-p.s. [see how rse cli uses hooked=true](https://github.com/reliverse/rse/blob/main/src/postbuild.ts)
-
-here’s an extended and improved section for your readme, keeping your lowercase style and adding clarity, options, and a bit more detail:
+### 4. `conv`
 
----
+not yet documented.
 
-### 2. `deps-dler-plugin`
+### 5. `deps`
 
 finds missing dependencies in your project by scanning your code for imports and comparing them to your `package.json`.
 
@@ -239,7 +195,11 @@ dler deps --all --directory ./src --include-builtins
 missing dependencies are shown only once, even if used in multiple files.  
 deep imports like `dep/some/file` or `@org/dep/some/thing` are always resolved to their root package.
 
-### 3. `libraries-dler-plugin`
+### 6. `inject`
+
+not yet documented.
+
+### 7. `libs`
 
 builds and publishes specific subdirectories of your main project as standalone packages.
 
@@ -275,9 +235,106 @@ libslist: {
 
 - more magic commands coming soon...
 
----
+### 8. `merge`
+
+not yet documented.
+
+### 9. `mono`
+
+not yet documented.
+
+### 10. `pub`
+
+pub command is separated for its own build-in plugin as well.
+
+it already calls build command by itself, so you don't need to run `dler build` separately.
+
+```bash
+dler pub ...
+```
+
+### 11. `relifso`
+
+```bash
+dler relifso init ...
+```
+
+### 12. `relinka`
+
+@reliverse/relinka's best friend. learn more in its [docs](https://github.com/reliverse/relinka).
+
+```bash
+dler relinka --console-to-relinka
+```
+
+### 13. `rempts`
+
+@reliverse/rempts's best friend. learn more in its [docs](https://github.com/reliverse/rempts).
+
+```bash
+dler rempts init --cmd my-cmd-1
+dler rempts init --cmds
+```
+
+### 14. `spell`
+
+**available spell types:**
+
+- `replace-line` — injects contents from one file into another
+- `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
+- `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
+
+**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  
+  - `true`: disables default behavior, so you can trigger the spell yourself (e.g. from your own cli function)
+
+more params coming soon...
+
+**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`)
+
+**using `hooked=true`:**
+
+- `// <dler-rename-file-"tsconfig.json"-{hooked=true}>` — renames the file, but only when you trigger it yourself (hooked from your side)
+
+**triggering spells:**
+
+from dler’s cli:  
+
+- `dler spell --trigger rename-file,... --files tsconfig.json,...`
+- `dler spell --trigger all`
+- `dler spell`
+
+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
+```
+
+p.s. [see how rse cli uses hooked=true](https://github.com/reliverse/rse/blob/main/src/postbuild.ts)
 
-### 4. `tools-dler-plugin`
+### 15. `tools`
 
 lets you run standalone dler features directly from the cli:
 

package/bin/app/build/cmd.js

@@ -0,0 +1,17 @@
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { dlerBuild } from "../../cli.js";
+export default defineCommand({
+  meta: {
+    name: "build",
+    description: "Build the project"
+  },
+  args: defineArgs({
+    dev: {
+      type: "boolean",
+      description: "Runs the CLI in dev mode"
+    }
+  }),
+  async run({ args }) {
+    await dlerBuild(args.dev);
+  }
+});

package/bin/app/cmds.js

@@ -0,0 +1,6 @@
+export async function getCmdRelifsoInit() {
+  return (await import("./relifso/init/cmd.js")).default;
+}
+export async function getCmdInjectTsExpectError() {
+  return (await import("./inject/expect/cmd.js")).default;
+}

package/bin/{cli/args → app}/inject/README.md

@@ -1,10 +1,10 @@
-# @reliverse/reinject | Reinjection CLI & Core
+# dler inject
 
-[💖 GitHub Sponsors](https://github.com/sponsors/blefnk) • [💬 Discord](https://discord.gg/Pb8uKbwpsJ) • [📦 NPM](https://npmjs.com/@reliverse/reinject) • [📚 Docs](https://blefnk.reliverse.org/blog/my-products/reinject)
+[💖 GitHub Sponsors](https://github.com/sponsors/blefnk) • [💬 Discord](https://discord.gg/Pb8uKbwpsJ) • [📦 NPM](https://npmjs.com/@reliverse/inject) • [📚 Docs](https://blefnk.reliverse.org/blog/my-products/inject)
 
-**@reliverse/reinject** handles the boring parts for you. For example:
+**@reliverse/inject** handles the boring parts for you. For example:
 
-- ✅ Need to insert `// @ts-expect-error` above a TypeScript error? Reinject’s got you.
+- ✅ Need to insert `// @ts-expect-error` above a TypeScript error? Inject’s got you.
 - 🔜 Fixing repetitive warns, lint suppressions, or compiler nags? One-liner.
 - 🔜 Even more features to come!
 
@@ -23,18 +23,18 @@ Make sure you have Git, Node.js, and bun•pnpm•yarn•npm installed.
 ### Installation
 
 ```bash
-bun i -g @reliverse/reinject
+bun i -g @reliverse/inject
 ```
 
 Or use with `bun x` (or `npx`):
 
 ```bash
-bun x @reliverse/reinject
+bun x @reliverse/inject
 ```
 
 ### Basic Usage
 
-**User config** in `reinject.config.ts`:
+**User config** in `inject.config.ts`:
 
 ```ts
 export default {
@@ -47,15 +47,15 @@ export default {
 
 ```bash
 # 1) Automatic mode:
-reinject ts-expect-error auto
+inject ts-expect-error auto
 # => runs `tsc`, finds errors, injects comment above them.
 
 # 2) Lines-file mode:
-reinject ts-expect-error linesA.txt linesB.txt
+inject ts-expect-error linesA.txt linesB.txt
 # => no TSC, just parses references from lines files
 
 # 3) Mixed:
-reinject ts-expect-error auto lines.txt
+inject ts-expect-error auto lines.txt
 # => merges TSC errors with references in lines.txt
 ```
 
@@ -63,41 +63,41 @@ reinject ts-expect-error auto lines.txt
 
 ```bash
 # When you need a custom comment:
-reinject ts-expect-error auto --comment="// @ts-expect-error FIXME"
+inject ts-expect-error auto --comment="// @ts-expect-error FIXME"
 ```
 
 Run on a TypeScript file with tsc output:
 
 ```bash
-reinject ts-expect-error src
+inject ts-expect-error src
 ```
 
 You can also run on a specific TypeScript file with manually generated tsc output:
 
 ```bash
 tsc --noEmit > tsc.log
-reinject tsc.log
+inject tsc.log
 rm tsc.log
 ```
 
 You can also run it directly on output from stdin:
 
 ```bash
-tsc --noEmit | reinject
+tsc --noEmit | inject
 ```
 
 Or use with other tools:
 
 ```bash
-eslint . | reinject
-biome check . | reinject
+eslint . | inject
+biome check . | inject
 ```
 
 ### Filter by error code or rule ID
 
 ```bash
-reinject tsc.log --code TS2322
-reinject eslint.log --rule no-unused-vars
+inject tsc.log --code TS2322
+inject eslint.log --rule no-unused-vars
 ```
 
 ## ✨ Examples
@@ -137,9 +137,9 @@ const x: string = 123;
 
 ## 🫶 Show some love
 
-If `@reliverse/reinject` saved you time or sanity:
+If `@reliverse/inject` saved you time or sanity:
 
-- ⭐ [Star the repo](https://github.com/reliverse/reinject)
+- ⭐ [Star the repo](https://github.com/reliverse/inject)
 - 💖 [Sponsor on GitHub](https://github.com/sponsors/blefnk)
 - 🫶 Share it with a dev friend!
 

package/bin/{cli/args/inject/inject-mod.js → app/inject/cmd.js}

@@ -1,9 +1,10 @@
 import { relinka } from "@reliverse/relinka";
-import { defineCommand, selectPrompt } from "@reliverse/rempts";
+import { defineCommand, runCmd, selectPrompt } from "@reliverse/rempts";
+import { getCmdInjectTsExpectError } from "../cmds.js";
 export default defineCommand({
   meta: {
     name: "cli",
-    description: "Runs the Reinject CLI interactive menu (displays list of available commands)"
+    description: "Runs the Inject command interactive menu (displays list of available commands)"
   },
   args: {
     dev: {
@@ -19,7 +20,7 @@ export default defineCommand({
   run: async ({ args }) => {
     const isDev = args.dev;
     relinka("verbose", `Running in ${isDev ? "dev" : "prod"} mode`);
-    await selectPrompt({
+    const cmd = await selectPrompt({
       title: "Select a command",
       options: [
         {
@@ -28,5 +29,8 @@ export default defineCommand({
         }
       ]
     });
+    if (cmd === "ts-expect-error") {
+      await runCmd(await getCmdInjectTsExpectError(), []);
+    }
   }
 });

package/bin/app/inject/expect/cmd.js

@@ -0,0 +1,43 @@
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { useTsExpectError } from "./impl.js";
+export default defineCommand({
+  meta: {
+    name: "expect",
+    version: "1.0.0",
+    description: "Inject `@ts-expect-error` above lines where TS errors occur"
+  },
+  args: defineArgs({
+    dev: {
+      type: "boolean",
+      description: "Run the CLI in dev mode"
+    },
+    files: {
+      type: "positional",
+      description: `'auto' or path(s) to line references file(s)`,
+      default: "auto"
+    },
+    comment: {
+      type: "string",
+      description: "Override the comment line to insert. Default is `// @ts-expect-error TODO: fix ts`"
+    },
+    tscPaths: {
+      type: "string",
+      description: "Optional: specify path(s) to restrict TSC processing (only effective when using 'auto')"
+    }
+  }),
+  async run({ args }) {
+    if (args.dev) {
+      relinka("verbose", "Using dev mode");
+    }
+    let pathsTsc = args.tscPaths;
+    if (pathsTsc === void 0 && args.files === "auto") {
+      pathsTsc = "./tsconfig.json";
+    }
+    await useTsExpectError({
+      files: [args.files],
+      comment: args.comment,
+      tscPaths: [pathsTsc]
+    });
+  }
+});

package/bin/app/inject/expect/impl.js

@@ -0,0 +1,162 @@
+import { relinka } from "@reliverse/relinka";
+import { execa } from "execa";
+import fs from "fs-extra";
+import path from "pathe";
+function parseCommand(command) {
+  const regex = /"([^"]+)"|'([^']+)'|(\S+)/g;
+  const args = [];
+  let match;
+  while (regex.exec(command) !== null) {
+    match = regex.exec(command);
+    if (match) {
+      const value = match[1] ?? match[2] ?? match[3];
+      if (value) {
+        args.push(value);
+      }
+    }
+  }
+  const cmd = args.shift() ?? "";
+  return { cmd, args };
+}
+async function parseLinesFile(linesFile) {
+  const fileContents = await fs.readFile(linesFile, "utf-8");
+  const splitted = fileContents.split(/\r?\n/);
+  const results = [];
+  for (const rawLine of splitted) {
+    const trimmed = rawLine.trim();
+    if (!trimmed) continue;
+    const firstMatch = trimmed.match(/^(\d+)\s+(.+?):(\d+)$/);
+    if (firstMatch?.[2] && firstMatch?.[3]) {
+      results.push({
+        filePath: firstMatch[2],
+        lineNumber: Number.parseInt(firstMatch[3], 10)
+      });
+      continue;
+    }
+    const secondMatch = trimmed.match(/^(.+?):(\d+)$/);
+    if (secondMatch?.[1] && secondMatch?.[2]) {
+      results.push({
+        filePath: secondMatch[1],
+        lineNumber: Number.parseInt(secondMatch[2], 10)
+      });
+    } else {
+      relinka("warn", `Line doesn't match expected format: ${trimmed}`);
+    }
+  }
+  return results;
+}
+async function runTscAndParseErrors(tscCommand, tscPaths) {
+  try {
+    const { cmd, args: cmdArgs } = parseCommand(tscCommand);
+    if (tscPaths?.length) {
+      cmdArgs.push(...tscPaths);
+    }
+    const subprocess = await execa(cmd, cmdArgs, { all: true, reject: false });
+    const combinedOutput = subprocess.all ?? "";
+    return parseErrorOutput(combinedOutput);
+  } catch (error) {
+    if (error && typeof error === "object" && "all" in error) {
+      const combined = error.all ?? "";
+      if (!combined) {
+        relinka("log", "TSC returned no error lines. Possibly no TS errors?");
+        return [];
+      }
+      return parseErrorOutput(combined);
+    }
+    return [];
+  }
+}
+function parseErrorOutput(output) {
+  const results = [];
+  const splitted = output.split(/\r?\n/);
+  const regex = /^(.+?)\((\d+),(\d+)\): error TS\d+: /;
+  for (const line of splitted) {
+    const match = line.trim().match(regex);
+    if (match?.[1] && match?.[2]) {
+      const file = match[1].replace(/\\/g, "/");
+      const row = Number.parseInt(match[2], 10);
+      if (row > 0) {
+        results.push({ filePath: file, lineNumber: row });
+      }
+    }
+  }
+  return results;
+}
+function isWithin(filePath, dirs) {
+  const absFile = path.resolve(filePath);
+  return dirs.some((dir) => {
+    const absDir = path.resolve(dir);
+    const normalizedDir = absDir.endsWith(path.sep) ? absDir : absDir + path.sep;
+    return absFile.startsWith(normalizedDir);
+  });
+}
+async function injectCommentIntoFiles(linesRecords, commentText) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const rec of linesRecords) {
+    const lines = byFile.get(rec.filePath) ?? [];
+    lines.push(rec.lineNumber);
+    byFile.set(rec.filePath, lines);
+  }
+  for (const [filePath, lineNums] of byFile.entries()) {
+    lineNums.sort((a, b) => b - a);
+    const absPath = path.resolve(filePath);
+    relinka(
+      "log",
+      `Injecting into ${absPath} at lines: ${lineNums.join(", ")}`
+    );
+    try {
+      const original = await fs.readFile(absPath, "utf-8");
+      const splitted = original.split(/\r?\n/);
+      for (const ln of lineNums) {
+        if (ln <= splitted.length) {
+          splitted.splice(ln - 1, 0, commentText);
+        } else {
+          relinka("warn", `Line ${ln} exceeds file length for ${absPath}`);
+        }
+      }
+      const newContent = splitted.join("\n");
+      await fs.writeFile(absPath, newContent, "utf-8");
+    } catch (error) {
+      relinka("error", `Failed editing ${filePath}: ${error}`);
+    }
+  }
+}
+export async function useTsExpectError(args) {
+  const finalComment = args.comment ?? "// @ts-expect-error TODO: fix ts";
+  const tscCommand = "tsc --project ./tsconfig.json --noEmit";
+  const lines = [];
+  const usedAuto = args.files.some((item) => item.toLowerCase() === "auto");
+  if (usedAuto) {
+    relinka("log", "Running TSC to discover error lines...");
+    try {
+      const discovered = await runTscAndParseErrors(tscCommand, args.tscPaths);
+      if (args.tscPaths?.length) {
+        const filtered = discovered.filter(
+          (rec) => args.tscPaths ? isWithin(rec.filePath, args.tscPaths) : true
+        );
+        lines.push(...filtered);
+      } else {
+        lines.push(...discovered);
+      }
+    } catch (error) {
+      relinka("error", `Failed running tsc: ${error}`);
+      process.exit(1);
+    }
+  }
+  for (const item of args.files) {
+    if (item.toLowerCase() === "auto") continue;
+    try {
+      const recs = await parseLinesFile(item);
+      lines.push(...recs);
+    } catch (error) {
+      relinka("error", `Failed reading lines file ${item}: ${error}`);
+    }
+  }
+  if (lines.length === 0) {
+    relinka("error", "No references found. Nothing to do.");
+    relinka("error", "Lines: ", JSON.stringify(lines));
+    process.exit(1);
+  }
+  await injectCommentIntoFiles(lines, finalComment);
+  relinka("success", "All lines processed successfully.");
+}

package/bin/app/pub/cmd.js

@@ -0,0 +1,17 @@
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { dlerPub } from "../../cli.js";
+export default defineCommand({
+  meta: {
+    name: "build",
+    description: "Build the project"
+  },
+  args: defineArgs({
+    dev: {
+      type: "boolean",
+      description: "Runs the CLI in dev mode"
+    }
+  }),
+  async run({ args }) {
+    await dlerPub(args.dev);
+  }
+});

package/bin/app/relifso/cmd.js

@@ -0,0 +1,36 @@
+import { relinka } from "@reliverse/relinka";
+import { defineCommand, runCmd, selectPrompt } from "@reliverse/rempts";
+import { getCmdRelifsoInit } from "../cmds.js";
+export default defineCommand({
+  meta: {
+    name: "cli",
+    description: "Runs the Relifso helper interactive menu (displays list of available commands)"
+  },
+  args: {
+    dev: {
+      type: "boolean",
+      description: "Runs the CLI in dev mode"
+    },
+    cwd: {
+      type: "string",
+      description: "The working directory to run the CLI in",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    const isDev = args.dev;
+    relinka("verbose", `Running in ${isDev ? "dev" : "prod"} mode`);
+    const cmd = await selectPrompt({
+      title: "Select a command",
+      options: [
+        {
+          value: "init",
+          label: "Initialize files"
+        }
+      ]
+    });
+    if (cmd === "init") {
+      await runCmd(await getCmdRelifsoInit(), []);
+    }
+  }
+});