@reliverse/dler 1.7.78 → 1.7.79

package/README.md

@@ -114,6 +114,47 @@ if you run just `dler` — it will display a list of commands which you can laun
 
 [build](#1-build) — [pub](#2-pub) — [agg](#3-agg) — [check](#4-check) — [conv](#5-conv) — [fs](#6-fs) — [init](#7-init) — [inject](#8-inject) — [libs](#9-libs) — [merge](#10-merge) — [migrate](#11-migrate) — [rempts](#12-rempts) — [x](#13-x) — [spell](#14-magic) — [split](#15-split) — [pack](#16-pack)
 
+### 0. `core`
+
+#### `install`
+
+```bash
+# Install all dependencies
+dler install
+
+# Install with workspace filtering
+dler install --filter "pkg-*" --filter "!pkg-c"
+dler install --filter "./packages/pkg-*"
+
+# Install specific package in filtered workspaces
+dler install lodash --filter "pkg-*"
+```
+
+#### `remove`
+
+```bash
+# Remove package from all workspaces
+dler remove lodash
+
+# Remove from specific workspaces
+dler remove lodash --filter "pkg-*" --filter "!pkg-c"
+```
+
+#### `update`
+
+when dler detects that you are in a monorepo, it will uses linked dependencies (`--linker`).
+
+```bash
+# Update all dependencies
+dler update
+
+# Update with workspace filtering
+dler update --filter "pkg-*" --filter "!pkg-c"
+
+# Update specific packages in filtered workspaces
+dler update lodash --filter "pkg-*"
+```
+
 ### 1. `build`
 
 since dler is fully modular, build command is separated for its own build-in plugin as well.
@@ -904,11 +945,156 @@ bun dler update
 
 - recursive lookup for deps in multiple package.json files (e.g. monorepo; or case when you have `C:/foo/bar1/package.json` and `C:/foo/bar2/package.json` and using `dler update` in `C:/foo`).
 
-## related
+## workspaces and catalogs
 
-special thanks to the project that inspired `@reliverse/dler`:
+dler has full workspaces and catalogs support for the package management commands. Catalog logic is similar to Bun across all package management commands.
 
-- [unjs/unbuild](https://github.com/unjs/unbuild#readme)
+### **Catalog Features:**
+
+#### **1. Install Dependencies as Catalogs**
+
+```bash
+# Add to default catalog
+dler install react react-dom --as-catalog default
+
+# Add to named catalog
+dler install jest testing-library --as-catalog testing
+dler install webpack babel --as-catalog build --catalog-name build
+
+# With workspace filtering
+dler install lodash --as-catalog default --filter "pkg-*"
+```
+
+#### **2. Remove Dependencies from Catalogs**
+
+```bash
+# Remove from default catalog
+dler remove react react-dom --from-catalog default
+
+# Remove from named catalog
+dler remove jest --from-catalog testing
+dler remove webpack --from-catalog build --catalog-name build
+```
+
+#### **3. List Catalogs**
+
+```bash
+# List all catalogs and their dependencies
+dler catalog list
+dler catalog ls
+```
+
+#### **4. Update Catalogs**
+
+```bash
+# Update all catalog dependencies to latest versions
+dler update --update-catalogs
+```
+
+### **Technical Implementation:**
+
+#### **Smart Version Management**
+
+- Dler automatically fetches latest versions from npm registry
+- Uses `^` and `~` prefixes for semver compatibility
+- Handles scoped packages correctly
+
+### **Catalog Structure Support:**
+
+#### **Default Catalog**
+
+```json
+{
+  "workspaces": {
+    "packages": ["packages/*"],
+    "catalog": {
+      "react": "^19.0.0",
+      "react-dom": "^19.0.0"
+    }
+  }
+}
+```
+
+#### **Named Catalogs**
+
+```json
+{
+  "workspaces": {
+    "packages": ["packages/*"],
+    "catalogs": {
+      "testing": {
+        "jest": "^30.0.0",
+        "testing-library": "^14.0.0"
+      },
+      "build": {
+        "webpack": "^5.88.2",
+        "babel": "^7.22.10"
+      }
+    }
+  }
+}
+```
+
+### **Usage Examples:**
+
+#### **Setting up a React Monorepo with Catalogs:**
+
+```bash
+# 1. Add core React dependencies to default catalog
+dler install react react-dom react-router-dom --as-catalog default
+
+# 2. Add build tools to named catalog
+dler install webpack babel --as-catalog build
+
+# 3. Add testing tools to named catalog
+dler install jest react-testing-library --as-catalog testing
+
+# 4. List all catalogs
+dler catalog list
+
+# 5. Update all catalogs to latest versions
+dler update --update-catalogs
+```
+
+#### **Workspace Package Usage:**
+
+```json
+// packages/app/package.json
+{
+  "dependencies": {
+    "react": "catalog:",
+    "react-dom": "catalog:",
+    "react-router-dom": "catalog:"
+  },
+  "devDependencies": {
+    "webpack": "catalog:build",
+    "jest": "catalog:testing"
+  }
+}
+```
+
+#### **Advanced Operations:**
+
+```bash
+# Add dependencies to specific workspaces as catalogs
+dler install lodash --as-catalog default --filter "pkg-*" --filter "!pkg-c"
+
+# Remove dependencies from catalogs in filtered workspaces
+dler remove typescript --from-catalog default --filter "pkg-*"
+
+# Update catalogs and then install
+dler update --update-catalogs
+dler install
+```
+
+### **Benefits:**
+
+1. **Consistency**: Ensures all packages use the same version of critical dependencies
+2. **Maintenance**: Update a dependency version in one place instead of across multiple package.json files
+3. **Clarity**: Makes it obvious which dependencies are standardized across your monorepo
+4. **Simplicity**: No need for complex version resolution strategies or external tools
+5. **Workspace Integration**: Seamlessly works with workspace filtering
+6. **Cross-Package Manager**: Works with Bun (full support) and provides helpful messages for others
 
 ## contributors
 
@@ -1011,6 +1197,12 @@ special thanks to the project that inspired `@reliverse/dler`:
 - [ ]  -c, --config=<val>                  Specify path to Bun config file. Default $cwd/bunfig.toml
 - [ ]  -h, --help                          Display this menu and exit
 
+## 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);

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

@@ -0,0 +1,13 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    action: {
+        type: "string";
+        description: string;
+        required: false;
+        default: string;
+    };
+    cwd: {
+        type: "string";
+        description: string;
+    };
+}>;
+export default _default;

package/bin/app/catalog/cmd.js

@@ -0,0 +1,48 @@
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { listCatalogs, isCatalogSupported } from "../../libs/sdk/sdk-impl/utils/pm/pm-catalog.js";
+import { detectPackageManager } from "../../libs/sdk/sdk-impl/utils/pm/pm-detect.js";
+export default defineCommand({
+  meta: {
+    name: "catalog",
+    version: "1.0.0",
+    description: "Manage dependency catalogs for monorepos. Usage example: `dler catalog list`"
+  },
+  args: defineArgs({
+    action: {
+      type: "string",
+      description: "Action to perform: list, ls",
+      required: false,
+      default: "list"
+    },
+    cwd: {
+      type: "string",
+      description: "Current working directory"
+    }
+  }),
+  async run({ args }) {
+    const { action, cwd } = args;
+    const packageManager = await detectPackageManager(cwd || process.cwd());
+    if (!packageManager) {
+      relinka("error", "Could not detect package manager");
+      return process.exit(1);
+    }
+    if (!isCatalogSupported(packageManager)) {
+      relinka(
+        "error",
+        `Catalogs are not supported by ${packageManager.name}. Only Bun supports catalogs.`
+      );
+      return process.exit(1);
+    }
+    switch (action) {
+      case "list":
+      case "ls":
+        await listCatalogs(cwd || process.cwd());
+        break;
+      default:
+        relinka("error", `Unknown action: ${action}`);
+        relinka("log", "Available actions: list, ls");
+        return process.exit(1);
+    }
+  }
+});

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

@@ -46,5 +46,17 @@ declare const _default: import("@reliverse/rempts").Command<{
         description: string;
         default: false;
     };
+    filter: {
+        type: "array";
+        description: string;
+    };
+    "as-catalog": {
+        type: "string";
+        description: string;
+    };
+    "catalog-name": {
+        type: "string";
+        description: string;
+    };
 }>;
 export default _default;

package/bin/app/install/cmd.js

@@ -5,6 +5,8 @@ import {
   dedupeDependencies,
   installDependencies
 } from "../../libs/sdk/sdk-impl/utils/pm/pm-api.js";
+import { addToCatalog, isCatalogSupported } from "../../libs/sdk/sdk-impl/utils/pm/pm-catalog.js";
+import { detectPackageManager } from "../../libs/sdk/sdk-impl/utils/pm/pm-detect.js";
 export default defineCommand({
   meta: {
     name: "install",
@@ -52,11 +54,56 @@ export default defineCommand({
       type: "boolean",
       description: "Run linter checks after updating dependencies",
       default: false
+    },
+    filter: {
+      type: "array",
+      description: "Filter workspaces to operate on (e.g., 'pkg-*', '!pkg-c', './packages/pkg-*')"
+    },
+    "as-catalog": {
+      type: "string",
+      description: "Install dependencies as catalog entries (e.g., 'default', 'testing', 'build')"
+    },
+    "catalog-name": {
+      type: "string",
+      description: "Name of the catalog to add dependencies to (used with --as-catalog)"
     }
   }),
   async run({ args }) {
     console.log("DEBUG: install command starting with args:", args);
-    const { action, name, linter, ...options } = args;
+    const {
+      action,
+      name,
+      linter,
+      filter,
+      "as-catalog": asCatalog,
+      "catalog-name": catalogName,
+      ...options
+    } = args;
+    if (filter && filter.length > 0) {
+      const packageManager = await detectPackageManager(process.cwd());
+      if (packageManager) {
+        options.filter = filter;
+      }
+    }
+    if (asCatalog && name) {
+      const packageManager = await detectPackageManager(process.cwd());
+      if (!packageManager) {
+        relinka("error", "Could not detect package manager");
+        return process.exit(1);
+      }
+      if (!isCatalogSupported(packageManager)) {
+        relinka(
+          "error",
+          `Catalogs are not supported by ${packageManager.name}. Only Bun supports catalogs.`
+        );
+        return process.exit(1);
+      }
+      const dependencies = Array.isArray(name) ? name : [name];
+      const catalogType = asCatalog === "default" ? "catalog" : "catalogs";
+      const actualCatalogName = asCatalog === "default" ? void 0 : catalogName || asCatalog;
+      await addToCatalog(dependencies, catalogType, actualCatalogName, options.cwd);
+      return;
+    }
     switch (action) {
       case "install":
       case "i":

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

@@ -39,6 +39,18 @@ declare const _default: import("@reliverse/rempts").Command<{
         description: string;
         default: false;
     };
+    filter: {
+        type: "array";
+        description: string;
+    };
+    "from-catalog": {
+        type: "string";
+        description: string;
+    };
+    "catalog-name": {
+        type: "string";
+        description: string;
+    };
     standalone: {
         type: "boolean";
         description: string;

package/bin/app/remove/cmd.js

@@ -6,6 +6,8 @@ import { execa } from "execa";
 import { lookpath } from "lookpath";
 import { homedir, platform } from "node:os";
 import { removeDependency } from "../../libs/sdk/sdk-impl/utils/pm/pm-api.js";
+import { removeFromCatalog, isCatalogSupported } from "../../libs/sdk/sdk-impl/utils/pm/pm-catalog.js";
+import { detectPackageManager } from "../../libs/sdk/sdk-impl/utils/pm/pm-detect.js";
 export default defineCommand({
   meta: {
     name: "remove",
@@ -46,6 +48,18 @@ export default defineCommand({
       description: "Run linter checks after removing dependencies",
       default: false
     },
+    filter: {
+      type: "array",
+      description: "Filter workspaces to operate on (e.g., 'pkg-*', '!pkg-c', './packages/pkg-*')"
+    },
+    "from-catalog": {
+      type: "string",
+      description: "Remove dependencies from catalog (e.g., 'default', 'testing', 'build')"
+    },
+    "catalog-name": {
+      type: "string",
+      description: "Name of the catalog to remove dependencies from (used with --from-catalog)"
+    },
     standalone: {
       type: "boolean",
       description: "Remove standalone dler installation",
@@ -53,7 +67,41 @@ export default defineCommand({
     }
   }),
   async run({ args }) {
-    const { action, name, linter, standalone, ...options } = args;
+    const {
+      action,
+      name,
+      linter,
+      standalone,
+      filter,
+      "from-catalog": fromCatalog,
+      "catalog-name": catalogName,
+      ...options
+    } = args;
+    if (filter && filter.length > 0) {
+      const packageManager = await detectPackageManager(process.cwd());
+      if (packageManager) {
+        options.filter = filter;
+      }
+    }
+    if (fromCatalog && name) {
+      const packageManager = await detectPackageManager(process.cwd());
+      if (!packageManager) {
+        relinka("error", "Could not detect package manager");
+        return process.exit(1);
+      }
+      if (!isCatalogSupported(packageManager)) {
+        relinka(
+          "error",
+          `Catalogs are not supported by ${packageManager.name}. Only Bun supports catalogs.`
+        );
+        return process.exit(1);
+      }
+      const dependencies = Array.isArray(name) ? name : [name];
+      const catalogType = fromCatalog === "default" ? "catalog" : "catalogs";
+      const actualCatalogName = fromCatalog === "default" ? void 0 : catalogName || fromCatalog;
+      await removeFromCatalog(dependencies, catalogType, actualCatalogName, options.cwd);
+      return;
+    }
     if (standalone) {
       await removeStandaloneDler();
       return;

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

@@ -70,5 +70,14 @@ declare const _default: import("@reliverse/rempts").Command<{
         description: string;
         default: false;
     };
+    filter: {
+        type: "array";
+        description: string;
+    };
+    "update-catalogs": {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
 }>;
 export default _default;

package/bin/app/update/cmd.js

@@ -8,6 +8,8 @@ import pMap from "p-map";
 import { readPackageJSON } from "pkg-types";
 import semver from "semver";
 import { getConfigBunfig } from "../../libs/sdk/sdk-impl/config/load.js";
+import { updateCatalogs, isCatalogSupported } from "../../libs/sdk/sdk-impl/utils/pm/pm-catalog.js";
+import { detectPackageManager } from "../../libs/sdk/sdk-impl/utils/pm/pm-detect.js";
 import { latestVersion } from "../../libs/sdk/sdk-impl/utils/pm/pm-meta.js";
 function isNpmAlias(versionSpec) {
   return versionSpec.startsWith("npm:");
@@ -93,6 +95,69 @@ async function getGlobalPackages(packageManager) {
     return {};
   }
 }
+async function runInstallCommand(packageManager, linker) {
+  try {
+    switch (packageManager.name) {
+      case "bun": {
+        const linkerArg = linker ? `--linker ${linker}` : "";
+        await $`bun install ${linkerArg}`;
+        break;
+      }
+      case "npm":
+        await $`npm install`;
+        break;
+      case "yarn":
+        await $`yarn install`;
+        break;
+      case "pnpm":
+        await $`pnpm install`;
+        break;
+      case "deno":
+        await $`deno cache --reload import_map.json`;
+        break;
+      default:
+        throw new Error(`Unsupported package manager: ${packageManager.name}`);
+    }
+  } catch (error) {
+    relinka("warn", `Failed to run install command for ${packageManager.name}: ${error}`);
+    throw error;
+  }
+}
+async function runInstallCommandWithFilter(packageManager, linker, filterArgs = []) {
+  try {
+    switch (packageManager.name) {
+      case "bun": {
+        const linkerArg = linker ? `--linker ${linker}` : "";
+        const filterStr = filterArgs.join(" ");
+        await $`bun install ${linkerArg} ${filterStr}`;
+        break;
+      }
+      case "npm": {
+        const npmFilterStr = filterArgs.join(" ");
+        await $`npm install ${npmFilterStr}`;
+        break;
+      }
+      case "yarn": {
+        const yarnFilterStr = filterArgs.join(" ");
+        await $`yarn install ${yarnFilterStr}`;
+        break;
+      }
+      case "pnpm": {
+        const pnpmFilterStr = filterArgs.join(" ");
+        await $`pnpm install ${pnpmFilterStr}`;
+        break;
+      }
+      case "deno":
+        await $`deno cache --reload import_map.json`;
+        break;
+      default:
+        throw new Error(`Unsupported package manager: ${packageManager.name}`);
+    }
+  } catch (error) {
+    relinka("warn", `Failed to run install command for ${packageManager.name}: ${error}`);
+    throw error;
+  }
+}
 async function updateGlobalPackage(packageManager, packageName) {
   try {
     if (packageManager === "npm") {
@@ -343,6 +408,15 @@ export default defineCommand({
       type: "boolean",
       description: "Interactively select which dependencies to update",
       default: false
+    },
+    filter: {
+      type: "array",
+      description: "Filter workspaces to operate on (e.g., 'pkg-*', '!pkg-c', './packages/pkg-*')"
+    },
+    "update-catalogs": {
+      type: "boolean",
+      description: "Update catalog dependencies to latest versions",
+      default: false
     }
   }),
   async run({ args }) {
@@ -350,24 +424,44 @@ export default defineCommand({
       if (args.global) {
         return await handleGlobalUpdates(args);
       }
+      if (args["update-catalogs"]) {
+        const packageManager = await detectPackageManager(process.cwd());
+        if (!packageManager) {
+          relinka("error", "Could not detect package manager");
+          return process.exit(1);
+        }
+        if (!isCatalogSupported(packageManager)) {
+          relinka(
+            "error",
+            `Catalogs are not supported by ${packageManager.name}. Only Bun supports catalogs.`
+          );
+          return process.exit(1);
+        }
+        await updateCatalogs(process.cwd());
+        return;
+      }
       const packageJsonPath = path.resolve(process.cwd(), "package.json");
       if (!await fs.pathExists(packageJsonPath)) {
         relinka("error", "No package.json found in current directory");
         return process.exit(1);
       }
       let effectiveLinker = args.linker;
+      let linkerSource = "CLI default";
       if (typeof Bun !== "undefined") {
         const bunfigConfig = await getConfigBunfig();
         if (bunfigConfig?.install?.linker) {
           const bunfigLinker = bunfigConfig.install.linker;
           if ((bunfigLinker === "isolated" || bunfigLinker === "hoisted") && args.linker === "hoisted") {
             effectiveLinker = bunfigLinker;
+            linkerSource = bunfigLinker === "hoisted" ? "bunfig.toml (same as default)" : "bunfig.toml";
           }
         }
       }
       if (args.linker !== "hoisted") {
         effectiveLinker = args.linker;
+        linkerSource = "CLI argument (explicit override)";
       }
+      relinka("verbose", `Using linker strategy: ${effectiveLinker} (from ${linkerSource})`);
       const packageJson = await readPackageJSON();
       const dependencies = packageJson.dependencies || {};
       const devDependencies = packageJson.devDependencies || {};
@@ -643,13 +737,39 @@ export default defineCommand({
         "utf8"
       );
       relinka("success", `Updated ${toUpdate.length} dependencies in package.json`);
-      if (typeof Bun !== "undefined" && !args["no-install"]) {
-        await $`bun install --linker ${effectiveLinker}`;
-        if (packageJson.scripts?.check && args["with-check-script"]) {
-          await $`bun check`;
+      if (!args["no-install"]) {
+        const packageManager = await detectPackageManager(process.cwd());
+        if (packageManager) {
+          try {
+            if (args.filter && args.filter.length > 0) {
+              const filterArgs = args.filter.flatMap((filter) => ["--filter", filter]);
+              await runInstallCommandWithFilter(packageManager, effectiveLinker, filterArgs);
+            } else {
+              await runInstallCommand(packageManager, effectiveLinker);
+            }
+            if (packageManager.name === "bun" && packageJson.scripts?.check && args["with-check-script"]) {
+              await $`bun check`;
+            }
+          } catch (error) {
+            relinka(
+              "warn",
+              `Install failed: ${error instanceof Error ? error.message : String(error)}`
+            );
+            relinka(
+              "info",
+              `Run '${packageManager.command} install' manually to apply the changes`
+            );
+          }
+        } else {
+          relinka("warn", "Could not detect package manager. Please run install manually.");
         }
       } else {
-        relinka("info", "Run your package manager's install command to apply the changes");
+        const packageManager = await detectPackageManager(process.cwd());
+        const installCommand = packageManager ? `${packageManager.command} install` : "your package manager's install command";
+        relinka(
+          "info",
+          `Skipped install step due to --no-install flag. Run '${installCommand}' to apply the changes.`
+        );
       }
     } catch (error) {
       relinka(

package/bin/libs/sdk/sdk-impl/config/info.js

@@ -1,5 +1,5 @@
 import { endPrompt, startPrompt } from "@reliverse/rempts";
-const version = "1.7.78";
+const version = "1.7.79";
 export async function showStartPrompt(isDev) {
   await startPrompt({
     titleColor: "inverse",

package/bin/libs/sdk/sdk-impl/utils/pm/pm-api.d.ts

@@ -7,8 +7,9 @@ import type { OperationOptions } from "./pm-types";
  * @param options.silent - Whether to run the command in silent mode.
  * @param options.packageManager - The package manager info to use (auto-detected).
  * @param options.frozenLockFile - Whether to install dependencies with frozen lock file.
+ * @param options.filter - Filter workspaces to operate on (e.g., 'pkg-*', '!pkg-c').
  */
-export declare function installDependencies(options?: Pick<OperationOptions, "cwd" | "silent" | "packageManager"> & {
+export declare function installDependencies(options?: Pick<OperationOptions, "cwd" | "silent" | "packageManager" | "filter"> & {
     frozenLockFile?: boolean;
 }): Promise<void>;
 /**
@@ -48,6 +49,7 @@ export declare function addDevDependency(name: string | string[], options?: Omit
  * @param options.dev - Whether to remove dev dependency.
  * @param options.workspace - The name of the workspace to use.
  * @param options.global - Whether to run the command in global mode.
+ * @param options.filter - Filter workspaces to operate on (e.g., 'pkg-*', '!pkg-c').
  */
 export declare function removeDependency(name: string | string[], options?: OperationOptions): Promise<void>;
 /**

package/bin/libs/sdk/sdk-impl/utils/pm/pm-api.js

@@ -17,7 +17,9 @@ export async function installDependencies(options = {}) {
     deno: ["install", "--frozen"]
   };
   const commandArgs = options.frozenLockFile ? pmToFrozenLockfileInstallCommand[resolvedOptions.packageManager.name] : ["install"];
-  await executeCommand(resolvedOptions.packageManager.command, commandArgs, {
+  const workspaceArgs = getWorkspaceArgs(resolvedOptions);
+  const finalArgs = [...commandArgs, ...workspaceArgs];
+  await executeCommand(resolvedOptions.packageManager.command, finalArgs, {
     cwd: resolvedOptions.cwd,
     silent: resolvedOptions.silent
   });

package/bin/libs/sdk/sdk-impl/utils/pm/pm-catalog.d.ts

@@ -0,0 +1,36 @@
+import type { PackageManager } from "./pm-types";
+/**
+ * Interface for catalog structure
+ */
+export interface CatalogStructure {
+    catalog?: Record<string, string>;
+    catalogs?: Record<string, Record<string, string>>;
+}
+/**
+ * Get catalog structure from package.json
+ */
+export declare function getCatalogStructure(cwd?: string): Promise<CatalogStructure>;
+/**
+ * Add dependencies to catalog
+ */
+export declare function addToCatalog(dependencies: string[], catalogType: "catalog" | "catalogs", catalogName?: string, cwd?: string): Promise<void>;
+/**
+ * Check if catalog is supported by package manager
+ */
+export declare function isCatalogSupported(packageManager: PackageManager): boolean;
+/**
+ * Get catalog reference format for a dependency
+ */
+export declare function getCatalogReference(dependency: string, catalogType: "catalog" | "catalogs", catalogName?: string): string;
+/**
+ * List all catalogs and their dependencies
+ */
+export declare function listCatalogs(cwd?: string): Promise<void>;
+/**
+ * Update catalog dependencies to latest versions
+ */
+export declare function updateCatalogs(cwd?: string): Promise<void>;
+/**
+ * Remove dependencies from catalog
+ */
+export declare function removeFromCatalog(dependencies: string[], catalogType: "catalog" | "catalogs", catalogName?: string, cwd?: string): Promise<void>;

package/bin/libs/sdk/sdk-impl/utils/pm/pm-catalog.js

@@ -0,0 +1,237 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { readPackageJSON } from "pkg-types";
+export async function getCatalogStructure(cwd = process.cwd()) {
+  try {
+    const packageJson = await readPackageJSON(cwd);
+    const workspaces = packageJson.workspaces || {};
+    return {
+      catalog: workspaces.catalog || packageJson.catalog || {},
+      catalogs: workspaces.catalogs || packageJson.catalogs || {}
+    };
+  } catch (error) {
+    relinka("warn", `Failed to read catalog structure: ${error}`);
+    return { catalog: {}, catalogs: {} };
+  }
+}
+export async function addToCatalog(dependencies, catalogType, catalogName, cwd = process.cwd()) {
+  try {
+    const packageJsonPath = path.resolve(cwd, "package.json");
+    const packageJson = await readPackageJSON(cwd);
+    const latestVersions = {};
+    for (const dep of dependencies) {
+      try {
+        const packageName = dep.split("@")[0] || dep;
+        const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
+        if (response.ok) {
+          const data = await response.json();
+          latestVersions[packageName] = `^${data.version}`;
+        } else {
+          latestVersions[packageName] = "latest";
+        }
+      } catch (error) {
+        relinka("warn", `Failed to get latest version for ${dep}: ${error}`);
+        latestVersions[dep] = "latest";
+      }
+    }
+    const updatedPackageJson = { ...packageJson };
+    if (catalogType === "catalog") {
+      if (!updatedPackageJson.workspaces) {
+        updatedPackageJson.workspaces = {};
+      }
+      if (!updatedPackageJson.workspaces.catalog) {
+        updatedPackageJson.workspaces.catalog = {};
+      }
+      Object.assign(updatedPackageJson.workspaces.catalog, latestVersions);
+      if (updatedPackageJson.catalog) {
+        Object.assign(updatedPackageJson.catalog, latestVersions);
+      }
+    } else if (catalogType === "catalogs" && catalogName) {
+      if (!updatedPackageJson.workspaces) {
+        updatedPackageJson.workspaces = {};
+      }
+      if (!updatedPackageJson.workspaces.catalogs) {
+        updatedPackageJson.workspaces.catalogs = {};
+      }
+      if (!updatedPackageJson.workspaces.catalogs[catalogName]) {
+        updatedPackageJson.workspaces.catalogs[catalogName] = {};
+      }
+      Object.assign(updatedPackageJson.workspaces.catalogs[catalogName], latestVersions);
+      if (updatedPackageJson.catalogs) {
+        if (!updatedPackageJson.catalogs[catalogName]) {
+          updatedPackageJson.catalogs[catalogName] = {};
+        }
+        Object.assign(updatedPackageJson.catalogs[catalogName], latestVersions);
+      }
+    }
+    await fs.writeFile(packageJsonPath, JSON.stringify(updatedPackageJson, null, 2) + "\n", "utf8");
+    relinka(
+      "success",
+      `Added ${dependencies.length} dependencies to ${catalogType}${catalogName ? ` (${catalogName})` : ""}`
+    );
+  } catch (error) {
+    relinka("error", `Failed to add dependencies to catalog: ${error}`);
+    throw error;
+  }
+}
+export function isCatalogSupported(packageManager) {
+  return packageManager.name === "bun";
+}
+export function getCatalogReference(dependency, catalogType, catalogName) {
+  if (catalogType === "catalog") {
+    return "catalog:";
+  } else if (catalogType === "catalogs" && catalogName) {
+    return `catalog:${catalogName}`;
+  }
+  return dependency;
+}
+export async function listCatalogs(cwd = process.cwd()) {
+  try {
+    const { catalog, catalogs } = await getCatalogStructure(cwd);
+    if ((!catalog || Object.keys(catalog).length === 0) && (!catalogs || Object.keys(catalogs).length === 0)) {
+      relinka("info", "No catalogs found in package.json");
+      return;
+    }
+    if (catalog && Object.keys(catalog).length > 0) {
+      relinka("info", "Default catalog:");
+      for (const [dep, version] of Object.entries(catalog)) {
+        relinka("log", `  ${dep}: ${version}`);
+      }
+    }
+    if (catalogs && Object.keys(catalogs).length > 0) {
+      for (const [catalogName, dependencies] of Object.entries(catalogs)) {
+        relinka("info", `
+Catalog '${catalogName}':`);
+        for (const [dep, version] of Object.entries(dependencies)) {
+          relinka("log", `  ${dep}: ${version}`);
+        }
+      }
+    }
+  } catch (error) {
+    relinka("error", `Failed to list catalogs: ${error}`);
+  }
+}
+export async function updateCatalogs(cwd = process.cwd()) {
+  try {
+    const { catalog, catalogs } = await getCatalogStructure(cwd);
+    const packageJsonPath = path.resolve(cwd, "package.json");
+    const packageJson = await readPackageJSON(cwd);
+    const updatedPackageJson = { ...packageJson };
+    let updatedCount = 0;
+    if (catalog && Object.keys(catalog).length > 0) {
+      const updatedCatalog = {};
+      for (const [dep, currentVersion] of Object.entries(catalog)) {
+        try {
+          const response = await fetch(`https://registry.npmjs.org/${dep}/latest`);
+          if (response.ok) {
+            const data = await response.json();
+            const latestVersion = `^${data.version}`;
+            if (latestVersion !== currentVersion) {
+              updatedCatalog[dep] = latestVersion;
+              updatedCount++;
+              relinka("log", `  ${dep}: ${currentVersion} \u2192 ${latestVersion}`);
+            } else {
+              updatedCatalog[dep] = currentVersion;
+            }
+          } else {
+            updatedCatalog[dep] = currentVersion;
+          }
+        } catch (error) {
+          relinka("warn", `Failed to update ${dep}: ${error}`);
+          updatedCatalog[dep] = currentVersion;
+        }
+      }
+      if (!updatedPackageJson.workspaces) {
+        updatedPackageJson.workspaces = {};
+      }
+      updatedPackageJson.workspaces.catalog = updatedCatalog;
+      if (updatedPackageJson.catalog) {
+        updatedPackageJson.catalog = updatedCatalog;
+      }
+    }
+    if (catalogs && Object.keys(catalogs).length > 0) {
+      if (!updatedPackageJson.workspaces) {
+        updatedPackageJson.workspaces = {};
+      }
+      if (!updatedPackageJson.workspaces.catalogs) {
+        updatedPackageJson.workspaces.catalogs = {};
+      }
+      for (const [catalogName, dependencies] of Object.entries(catalogs)) {
+        const updatedNamedCatalog = {};
+        for (const [dep, currentVersion] of Object.entries(dependencies)) {
+          try {
+            const response = await fetch(`https://registry.npmjs.org/${dep}/latest`);
+            if (response.ok) {
+              const data = await response.json();
+              const latestVersion = `^${data.version}`;
+              if (latestVersion !== currentVersion) {
+                updatedNamedCatalog[dep] = latestVersion;
+                updatedCount++;
+                relinka("log", `  ${catalogName}:${dep}: ${currentVersion} \u2192 ${latestVersion}`);
+              } else {
+                updatedNamedCatalog[dep] = currentVersion;
+              }
+            } else {
+              updatedNamedCatalog[dep] = currentVersion;
+            }
+          } catch (error) {
+            relinka("warn", `Failed to update ${catalogName}:${dep}: ${error}`);
+            updatedNamedCatalog[dep] = currentVersion;
+          }
+        }
+        updatedPackageJson.workspaces.catalogs[catalogName] = updatedNamedCatalog;
+        if (updatedPackageJson.catalogs) {
+          updatedPackageJson.catalogs[catalogName] = updatedNamedCatalog;
+        }
+      }
+    }
+    await fs.writeFile(packageJsonPath, JSON.stringify(updatedPackageJson, null, 2) + "\n", "utf8");
+    if (updatedCount > 0) {
+      relinka("success", `Updated ${updatedCount} catalog dependencies`);
+    } else {
+      relinka("success", "All catalog dependencies are up to date");
+    }
+  } catch (error) {
+    relinka("error", `Failed to update catalogs: ${error}`);
+    throw error;
+  }
+}
+export async function removeFromCatalog(dependencies, catalogType, catalogName, cwd = process.cwd()) {
+  try {
+    const packageJsonPath = path.resolve(cwd, "package.json");
+    const packageJson = await readPackageJSON(cwd);
+    const updatedPackageJson = { ...packageJson };
+    if (catalogType === "catalog") {
+      if (updatedPackageJson.workspaces?.catalog) {
+        for (const dep of dependencies) {
+          delete updatedPackageJson.workspaces.catalog[dep];
+        }
+      }
+      if (updatedPackageJson.catalog) {
+        for (const dep of dependencies) {
+          delete updatedPackageJson.catalog[dep];
+        }
+      }
+    } else if (catalogType === "catalogs" && catalogName) {
+      if (updatedPackageJson.workspaces?.catalogs?.[catalogName]) {
+        for (const dep of dependencies) {
+          delete updatedPackageJson.workspaces.catalogs[catalogName][dep];
+        }
+      }
+      if (updatedPackageJson.catalogs?.[catalogName]) {
+        for (const dep of dependencies) {
+          delete updatedPackageJson.catalogs[catalogName][dep];
+        }
+      }
+    }
+    await fs.writeFile(packageJsonPath, JSON.stringify(updatedPackageJson, null, 2) + "\n", "utf8");
+    relinka(
+      "success",
+      `Removed ${dependencies.length} dependencies from ${catalogType}${catalogName ? ` (${catalogName})` : ""}`
+    );
+  } catch (error) {
+    relinka("error", `Failed to remove dependencies from catalog: ${error}`);
+    throw error;
+  }
+}

package/bin/libs/sdk/sdk-impl/utils/pm/pm-types.d.ts

@@ -16,6 +16,9 @@ export interface OperationOptions {
     dev?: boolean;
     workspace?: boolean | string;
     global?: boolean;
+    filter?: string[];
+    asCatalog?: string;
+    catalogName?: string;
 }
 export interface DetectPackageManagerOptions {
     /**

package/bin/libs/sdk/sdk-impl/utils/pm/pm-utils.d.ts

@@ -4,7 +4,7 @@ type NonPartial<T> = {
     [P in keyof T]-?: T[P];
 };
 export declare const NO_PACKAGE_MANAGER_DETECTED_ERROR_MSG = "No package manager auto-detected.";
-export declare function resolveOperationOptions(options?: OperationOptions): Promise<NonPartial<Pick<OperationOptions, "cwd" | "silent" | "dev" | "global">> & Pick<OperationOptions, "workspace"> & {
+export declare function resolveOperationOptions(options?: OperationOptions): Promise<NonPartial<Pick<OperationOptions, "cwd" | "silent" | "dev" | "global">> & Pick<OperationOptions, "workspace" | "filter" | "asCatalog" | "catalogName"> & {
     packageManager: PackageManager;
 }>;
 export declare function getWorkspaceArgs(options: Awaited<ReturnType<typeof resolveOperationOptions>>): string[];

package/bin/libs/sdk/sdk-impl/utils/pm/pm-utils.js

@@ -71,10 +71,20 @@ export async function resolveOperationOptions(options = {}) {
     packageManager,
     dev: options.dev ?? false,
     workspace: options.workspace,
+    filter: options.filter,
+    asCatalog: options.asCatalog,
+    catalogName: options.catalogName,
     global: options.global ?? false
   };
 }
 export function getWorkspaceArgs(options) {
+  const args = [];
+  if (options.filter && options.filter.length > 0) {
+    for (const filter of options.filter) {
+      args.push("--filter", filter);
+    }
+    return args;
+  }
   if (!options.workspace) {
     return [];
   }

package/package.json

@@ -37,7 +37,7 @@
     "pretty-ms": "^9.2.0",
     "registry-auth-token": "^5.1.0",
     "registry-url": "^7.2.0",
-    "rollup": "^4.46.0",
+    "rollup": "^4.46.1",
     "rollup-plugin-dts": "^6.2.1",
     "scule": "^1.3.0",
     "semver": "^7.7.2",
@@ -52,7 +52,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.7.78",
+  "version": "1.7.79",
   "keywords": [
     "reliverse",
     "cli",