@reliverse/dler 1.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Nazar Kornienko (blefnk), Reliverse
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,312 @@
+# dler (prev. relidler) • reliverse bundler
+
+[💖 github sponsors](https://github.com/sponsors/blefnk) — [💬 discord](https://discord.gg/pb8ukbwpsj) — [✨ repo](https://github.com/reliverse/dler-js-bundler) — [📦 npm](https://npmjs.com/@reliverse/dler) — [📚 docs](https://docs.reliverse.org)
+
+> @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.
+
+## features
+
+- 😘 replacement for `unbuild`
+- ⚡ `dler` works via cli and sdk
+- 📦 automated npm/jsr publishing
+- ✅ ensures reliable js/ts builds
+- 🔄 handles automatic version bumps
+- 🔧 eliminates `package.json` headaches
+- 🎯 optimized for speed and modern workflows
+- ✨ packed with powerful features under the hood
+- 🛠️ converts typescript aliases to relative paths
+- 🔌 plugin system with two built-in plugins included
+- 📝 highly configurable flow via a configuration file
+- 🔜 `libraries` plugin —> dler monorepo implementation
+- 🪄 magic spells (built-in plugin)
+
+### supported bundlers
+
+- ✅ [mkdist](https://github.com/unjs/mkdist#readme)
+- ✅ jsr
+- 🏗️ copy
+- 🏗️ [bun](https://bun.sh/docs/bundler)
+- 🏗️ [rollup](https://rollupjs.org)
+- 🏗️ [untyped](https://untyped.unjs.io)
+- 🔜 [tsdown](https://rolldown.rs)
+- 🔜 copy (prev. jsr)
+
+**legend**:
+
+- ✅ well tested with big projects
+- 🏗️ not well tested yet
+- 🔜 coming soon
+
+## getting started
+
+ensure git, node.js, and bun/pnpm/yarn/npm are installed. then:
+
+### playground
+
+> **💡 tip**:
+> want to test dler before integrating it into your project?
+> clone the repo and build it using dler itself!
+
+```sh
+git clone https://github.com/reliverse/dler.git
+cd dler
+bun i
+bun dev # bun src/main.ts --dev
+```
+
+### installation
+
+1. **install globally**:
+
+    ```sh
+    bun i -g @reliverse/dler
+    ```
+
+    **or update as needed**:
+
+    ```sh
+    bun -g update --latest
+    ```
+
+2. **prepare your project**:
+
+    a. **configure `.gitignore`**:
+
+    ```sh
+    echo "dist*" >> .gitignore
+    echo "logs" >> .gitignore
+    ```
+
+    b. **install config intellisense**:
+
+    ```sh
+    bun add -d @reliverse/dler-cfg
+    ```
+
+    c. **initialize config**:
+
+    ```sh
+    dler cli
+    ```
+
+    - the `.config/dler.ts` file is automatically created on first run.
+    - **it's recommended to customize this file according to your needs.**
+    - you can check an example config here: [.config/dler.ts](https://github.com/reliverse/dler-js-bundler/blob/main/.config/dler.ts)
+
+3. **run and enjoy**:
+
+    ```sh
+    dler cli
+    ```
+
+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)).
+
+### 1. `magic-spells-dler-plugin`
+
+**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 spells --trigger rename-file,... --files tsconfig.json,...`
+- `dler spells --trigger all`
+- `dler spells`
+
+from your own code:
+
+```ts
+await dler.spells({ spells: ["rename-file"], files: [] });
+// await dler.spells({}) // 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)
+
+here’s an extended and improved section for your readme, keeping your lowercase style and adding clarity, options, and a bit more detail:
+
+---
+
+### 2. `deps-dler-plugin`
+
+finds missing dependencies in your project by scanning your code for imports and comparing them to your `package.json`.
+
+**what it does:**
+
+- traverses all `.js`, `.jsx`, `.ts`, and `.tsx` files in your project (by default, in the current directory)
+- detects all used packages, including scoped ones (`@org/dep-name`)
+- supports both es modules (`import ... from "dep"`) and commonjs (`require("dep")`)
+- normalizes deep imports like `dep/some/file` to just `dep`
+- ignores local/relative imports (`./foo`, `../bar`)
+- skips `node_modules`, `.git`, and common build folders
+- compares all used packages to those listed in your `package.json`
+- shows you which dependencies are missing (not listed)
+- can also show all used dependencies (listed and missing)
+- optionally includes node.js built-in modules in the report
+- outputs results in a readable format or as json
+
+**usage examples:**
+
+```bash
+# basic usage - scan current directory
+dler deps
+
+# scan a specific directory
+dler deps --directory ./my-project
+
+# show all dependencies (both listed and missing)
+dler deps --all
+
+# ignore specific patterns
+dler deps --ignore "test/**,example/**"
+
+# output in json format
+dler deps --json
+
+# include node.js built-in modules
+dler deps --include-builtins
+
+# combine options
+dler deps --all --directory ./src --include-builtins
+```
+
+**pro tip:**  
+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`
+
+builds and publishes specific subdirectories of your main project as standalone packages.
+
+**usage example**:  
+using `@reliverse/dler-cfg` to package [src/libs/cfg](https://github.com/reliverse/dler-js-bundler/tree/main/src/libs/cfg):
+
+```ts
+// .config/dler.ts
+libsactmode: "main-and-libs",
+libsdirdist: "dist-libs",
+libsdirsrc: "src/libs",
+libslist: {
+  "@reliverse/dler-cfg": {
+    libdeclarations: true,
+    libdescription: "@reliverse/dler defineconfig",
+    libdirname: "cfg",
+    libmainfile: "cfg/cfg-main.ts",
+    libpkgkeepdeps: false,
+    libtranspileminify: true,
+  },
+},
+```
+
+**dler task commands**:
+
+- `// dler-replace-line` tells dler to grab the contents of `../../types.ts` and inject them directly in place of your command definition.
+
+  ```ts
+  export * from "../../types.js"; // dler-replace-line
+  // or:
+  export type { specificTypeName1, specificTypeName2 } from "../../types.js"; // dler-replace-line
+  ```
+
+- more magic commands coming soon...
+
+---
+
+### 4. `tools-dler-plugin`
+
+lets you run standalone dler features directly from the cli:
+
+```bash
+dler tools --tool <tool> --input <dir> --out <file> [options]
+```
+
+**available tools**:
+
+- `agg`: generates aggregator file with content like `export { getsomething } from "./utils.js"`. **note**: currently it replaces the file content, not appends.
+
+**usage example**: if you're exploring the example [playground](#playground), you can try the following:
+
+1. open [src/libs/sdk/sdk-main.ts](https://github.com/reliverse/dler-js-bundler/blob/main/src/libs/sdk/sdk-main.ts) in your ide.
+2. press `ctrl+a`, then `backspace`. run the command below and watch the magic happen:
+
+```bash
+bun tools:agg # shortcut for:
+bun src/main.ts tools --dev --tool agg --input src/libs/sdk/sdk-impl --out src/libs/sdk/sdk-main.ts --recursive --named --strip src/libs/sdk
+```
+
+## api (for advanced users)
+
+the sdk lets you build custom dler cli plugins or even extend your own cli tools.
+
+```sh
+bun add @reliverse/dler-sdk
+```
+
+**usage example**: [@reliverse/rse](https://github.com/reliverse/rse-website-builder) leverages this sdk to extend its functionality.
+
+## todo
+
+- [x] ~~implement stable `regular` build and publish~~
+- [ ] implement stable `library` build and publish
+- [ ] achieve full drop-in replacement for `unbuild`
+- [ ] support auto migration from `build.config.ts`
+- [ ] allow plugins to extend dler's `defineconfig`
+- [ ] support configuration via `.config/rse.{ts,jsonc}`
+- [ ] make config file optional with sensible defaults
+
+## related
+
+special thanks to the project that inspired `@reliverse/dler`:
+
+- [unjs/unbuild](https://github.com/unjs/unbuild#readme)
+
+## support
+
+- if dler saves you time and effort, please consider supporting its development: [github sponsors](https://github.com/sponsors/blefnk);
+- even a simple star on [github](https://github.com/reliverse/dler) shows your love. thank you!
+
+## license
+
+🩷 [mit](./license) © 2025 [blefnk nazar kornienko](https://github.com/blefnk)

package/bin/cli/args/conv/README.md

@@ -0,0 +1,3 @@
+# converter
+
+dler arg which allows you to convert anything into anything. Quickly. Smoothly.

package/bin/cli/args/deps/analyzer.js

@@ -0,0 +1,42 @@
+import { readFile, findSourceFiles, readPackageJson } from "./filesystem.js";
+import {
+  extractPackageNames,
+  getListedDependencies,
+  getBuiltinModules
+} from "./parser.js";
+export const analyzeDependencies = async (options) => {
+  const packageJson = await readPackageJson(options.directory);
+  const listedDependencies = getListedDependencies(packageJson);
+  const sourceFiles = await findSourceFiles(
+    options.directory,
+    options.ignorePatterns
+  );
+  const builtinModules = getBuiltinModules();
+  const allDependencies = /* @__PURE__ */ new Set();
+  for (const filePath of sourceFiles) {
+    const fileContent = await readFile(filePath);
+    const packageNames = extractPackageNames(fileContent);
+    for (const packageName of packageNames) {
+      allDependencies.add(packageName);
+    }
+  }
+  const missingDependencies = /* @__PURE__ */ new Set();
+  const builtinModulesList = [];
+  for (const dependency of allDependencies) {
+    if (!listedDependencies.has(dependency)) {
+      if (builtinModules.has(dependency)) {
+        if (options.includeBuiltins) {
+          builtinModulesList.push(dependency);
+        }
+      } else {
+        missingDependencies.add(dependency);
+      }
+    }
+  }
+  return {
+    missingDependencies: Array.from(missingDependencies).sort(),
+    allDependencies: Array.from(allDependencies).sort(),
+    listedDependencies: Array.from(listedDependencies).sort(),
+    builtinModules: builtinModulesList.sort()
+  };
+};

package/bin/cli/args/deps/filesystem.js

@@ -0,0 +1,42 @@
+import { glob } from "glob";
+import fs from "node:fs";
+import path from "node:path";
+import util from "node:util";
+const readFileAsync = util.promisify(fs.readFile);
+export const findSourceFiles = async (directory, ignorePatterns) => {
+  const pattern = `${directory}/**/*.{js,jsx,ts,tsx}`;
+  const defaultIgnores = [
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/build/**",
+    "**/dist/**",
+    "**/dist-npm/**",
+    "**/dist-jsr/**",
+    "**/dist-libs/**",
+    "**/coverage/**"
+  ];
+  const allIgnores = [...defaultIgnores, ...ignorePatterns];
+  return await glob(pattern, {
+    ignore: allIgnores,
+    absolute: true,
+    nodir: true
+  });
+};
+export const readFile = async (filePath) => {
+  try {
+    return await readFileAsync(filePath, "utf8");
+  } catch (error) {
+    console.error(`Error reading file ${filePath}:`, error);
+    return "";
+  }
+};
+export const readPackageJson = async (directory) => {
+  const packageJsonPath = path.join(directory, "package.json");
+  try {
+    const content = await readFile(packageJsonPath);
+    return JSON.parse(content);
+  } catch (error) {
+    console.error("Error reading package.json:", error);
+    return {};
+  }
+};

package/bin/cli/args/deps/formatter.js

@@ -0,0 +1,65 @@
+import chalk from "chalk";
+export const formatOutput = (result, options) => {
+  if (options.json) {
+    return JSON.stringify(result, null, 2);
+  }
+  let output = "";
+  output += chalk.bold.blue("\nMissing Dependencies Finder Results\n");
+  output += chalk.gray("---------------------------------------\n\n");
+  output += chalk.bold("Statistics:\n");
+  output += `${chalk.gray("\u2022 ")}Total dependencies found: ${result.allDependencies.length}
+`;
+  output += `${chalk.gray("\u2022 ")}Listed in package.json: ${result.listedDependencies.length}
+`;
+  output += `${chalk.gray("\u2022 ")}Missing from package.json: ${result.missingDependencies.length}
+`;
+  if (options.includeBuiltins) {
+    output += `${chalk.gray("\u2022 ")}Node.js built-in modules: ${result.builtinModules.length}
+`;
+  }
+  output += "\n";
+  if (result.missingDependencies.length > 0) {
+    output += chalk.bold.red("Missing Dependencies:\n");
+    for (const dep of result.missingDependencies) {
+      output += `${chalk.gray("\u2022 ")}${chalk.yellow(dep)}
+`;
+    }
+    output += "\n";
+    output += chalk.gray("To install, run:\n");
+    output += chalk.cyan(
+      `npm install ${result.missingDependencies.join(" ")}
+
+`
+    );
+  } else {
+    output += chalk.bold.green("No missing dependencies found! \u{1F389}\n\n");
+  }
+  if (options.includeBuiltins && result.builtinModules.length > 0) {
+    output += chalk.bold.blue("Node.js Built-in Modules Used:\n");
+    for (const dep of result.builtinModules) {
+      output += `${chalk.gray("\u2022 ")}${chalk.blue(dep)}
+`;
+    }
+    output += "\n";
+  }
+  if (options.showAll) {
+    output += chalk.bold("All Dependencies:\n");
+    output += chalk.gray("(\u2713 = listed in package.json, \u2717 = missing)\n");
+    for (const dep of result.allDependencies) {
+      const isListed = result.listedDependencies.includes(dep);
+      const isBuiltin = result.builtinModules.includes(dep);
+      if (isListed) {
+        output += `${chalk.gray("\u2022 ") + chalk.green("\u2713 ") + dep}
+`;
+      } else if (isBuiltin) {
+        output += `${chalk.gray("\u2022 ")}${chalk.blue("\u26A1 ")}${dep}${chalk.gray(" (built-in)")}
+`;
+      } else {
+        output += `${chalk.gray("\u2022 ")}${chalk.red("\u2717 ")}${chalk.yellow(dep)}
+`;
+      }
+    }
+    output += "\n";
+  }
+  return output;
+};

package/bin/cli/args/deps/mod.js

@@ -0,0 +1,48 @@
+import { re } from "@reliverse/relico";
+import { Command } from "commander";
+import path from "node:path";
+import { analyzeDependencies } from "./analyzer.js";
+import { formatOutput } from "./formatter.js";
+export const createCli = () => {
+  const program = new Command();
+  program.name("deps").description("Find dependencies used but not listed in package.json").version("1.0.0").option(
+    "-d, --directory <path>",
+    "directory to scan (defaults to current directory)",
+    "."
+  ).option(
+    "-a, --all",
+    "show all dependencies (both listed and not listed)",
+    false
+  ).option("-i, --ignore <patterns>", "comma-separated patterns to ignore", "").option("-j, --json", "output in JSON format", false).option(
+    "-b, --include-builtins",
+    "include Node.js built-in modules in the output",
+    false
+  ).action(async (cmdOptions) => {
+    try {
+      const directory = path.resolve(cmdOptions.directory);
+      const ignorePatterns = cmdOptions.ignore ? cmdOptions.ignore.split(",") : [];
+      const options = {
+        directory,
+        showAll: cmdOptions.all,
+        ignorePatterns,
+        json: cmdOptions.json,
+        includeBuiltins: cmdOptions.includeBuiltins
+      };
+      console.log(re.gray(`Scanning directory: ${directory}`));
+      const result = await analyzeDependencies(options);
+      const output = formatOutput(result, options);
+      console.log(output);
+      if (result.missingDependencies.length > 0) {
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error("Error:", error);
+      process.exit(1);
+    }
+  });
+  return program;
+};
+const cli = createCli();
+if (require.main === module) {
+  cli.parse(process.argv);
+}

package/bin/cli/args/deps/parser.js

@@ -0,0 +1,59 @@
+import { builtinModules } from "node:module";
+const importRegexes = [
+  // ES modules
+  /import\s+(?:{[^}]*}|\*\s+as\s+[^,]*|[^,{]*)\s+from\s+["']([^"']+)["']/g,
+  // Dynamic imports
+  /import\(["']([^"']+)["']\)/g,
+  // CommonJS requires
+  /require\(["']([^"']+)["']\)/g,
+  // Export from
+  /export\s+(?:{[^}]*}|\*)\s+from\s+["']([^"']+)["']/g
+];
+export const extractPackageNames = (fileContent) => {
+  const packageNames = /* @__PURE__ */ new Set();
+  for (const regex of importRegexes) {
+    let match;
+    const clonedRegex = new RegExp(regex.source, regex.flags);
+    for (; ; ) {
+      match = clonedRegex.exec(fileContent);
+      if (match === null) {
+        break;
+      }
+      const importPath = match[1];
+      if (importPath) {
+        const packageName = normalizePackageName(importPath);
+        if (packageName) {
+          packageNames.add(packageName);
+        }
+      }
+    }
+  }
+  return packageNames;
+};
+export const normalizePackageName = (importPath) => {
+  if (importPath.startsWith(".") || importPath.startsWith("/")) {
+    return null;
+  }
+  if (importPath.startsWith("@")) {
+    const scopedMatch = importPath.match(/^(@[^/]+\/[^/]+)/);
+    return scopedMatch ? scopedMatch[1] ?? null : null;
+  }
+  const match = importPath.match(/^([^/]+)/);
+  return match ? match[1] ?? null : null;
+};
+export const getListedDependencies = (packageJson) => {
+  const listedDependencies = /* @__PURE__ */ new Set();
+  const allDependencies = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies,
+    ...packageJson.peerDependencies,
+    ...packageJson.optionalDependencies
+  };
+  for (const dep of Object.keys(allDependencies || {})) {
+    listedDependencies.add(dep);
+  }
+  return listedDependencies;
+};
+export const getBuiltinModules = () => {
+  return new Set(builtinModules);
+};