@reliverse/dler 1.7.73 → 1.7.75

package/README.md

@@ -1,4 +1,4 @@
-# 🧬 dler • unified package manager with sweet powers
+# 🧬 dler • extend your bun/pnpm/yarn/npm usage
 
 [sponsor](https://github.com/sponsors/blefnk) — [discord](https://discord.gg/pb8ukbwpsj) — [github](https://github.com/reliverse/dler) — [npm](https://npmjs.com/@reliverse/dler)
 
@@ -53,7 +53,7 @@ it is recommended to install dler both globally and as a dev dependency:
 - **global install** — `bun add -g @reliverse/dler` — lets you use dler anywhere, like a system-level cli.
 - **dev dependency** — `bun add -D @reliverse/dler` — pins the version per project, so all contributors use the same version.
 
-instead of global install, you can alternatively install dler as a standalone binary: `bunx @reliverse/dler `
+instead of global install, you can alternatively install dler as a standalone binary: `bunx @reliverse/dler`
 
 > usage depends on how dler is installed:
 >

package/bin/app/agg/cmd.js

@@ -1,6 +1,6 @@
 import path from "@reliverse/pathkit";
-import { defineArgs, defineCommand, inputPrompt } from "@reliverse/rempts";
-import { useAggregator } from "./impl.js";
+import { inputPrompt, defineArgs, defineCommand } from "@reliverse/rempts";
+import { useAggregator } from "../../libs/sdk/sdk-impl/utils/agg/agg.js";
 export default defineCommand({
   args: defineArgs({
     imports: {

package/bin/app/build/postbuild.js

@@ -14,6 +14,7 @@ export async function dlerPostBuild(isDev, debugDontCopyNonBuildFiles) {
   relinka("info", "\u2014 \u2014 \u2014 dlerPostBuild \u2014 \u2014 \u2014");
   const config = await getConfigDler();
   await resolveAllCrossLibs(
+    "package",
     ALIAS_TO_REPLACE,
     ["npm", "jsr"],
     config.buildPreExtensions,

package/bin/app/cmds.d.ts

@@ -1,19 +1,245 @@
 import type { Command } from "@reliverse/rempts";
+interface CommandArgsMap {
+    agg: {
+        imports?: boolean;
+        input?: string;
+        named?: boolean;
+        out?: string;
+        recursive?: boolean;
+        strip?: string;
+        sort?: boolean;
+        header?: string;
+        verbose?: boolean;
+        includeInternal?: boolean;
+        internalMarker?: string;
+        override?: boolean;
+        extensions?: string;
+        separateTypesFile?: boolean;
+        typesOut?: string;
+        nonInteractive?: boolean;
+    };
+    build: {
+        dev?: boolean;
+        debugOnlyCopyNonBuildFiles?: boolean;
+        debugDontCopyNonBuildFiles?: boolean;
+    };
+    build_binary: {
+        input?: string;
+        targets?: string;
+        outdir?: string;
+        minify?: boolean;
+        sourcemap?: boolean;
+        bytecode?: boolean;
+        clean?: boolean;
+        parallel?: boolean;
+        external?: string[];
+    };
+    check: {
+        dev?: boolean;
+        directory?: string;
+        checks?: string;
+        strict?: boolean;
+        json?: boolean;
+        deps?: boolean;
+        all?: boolean;
+        ignore?: string;
+        builtins?: boolean;
+        peer?: boolean;
+        optional?: boolean;
+        fix?: boolean;
+        depth?: number;
+    };
+    conv: {};
+    create: {
+        template?: string;
+        mode?: "template" | "files";
+        fileType?: string;
+        destDir?: string;
+        multiple?: boolean;
+        parallel?: boolean;
+        concurrency?: string;
+        cwd?: string;
+    };
+    fs: {
+        mode: "copy" | "rm" | "rename";
+        target: string;
+        nonInteractive?: boolean;
+        source?: string;
+        destination?: string;
+        recursive?: boolean;
+        preserveStructure?: boolean;
+        increment?: boolean;
+        concurrency?: number;
+        gitignore?: boolean;
+        prepareMyCLI?: boolean;
+        revert?: boolean;
+        useDtsTxtForPrepareMyCLI?: boolean;
+    };
+    get: {};
+    init: {};
+    inject: {};
+    install: {
+        action?: string;
+        name?: string;
+        global?: boolean;
+        cwd?: string;
+        workspace?: boolean;
+        silent?: boolean;
+        recreateLockFile?: boolean;
+        linter?: boolean;
+    };
+    libs: {
+        init: string;
+        overwrite?: boolean;
+    };
+    magic: {
+        targets: string[];
+        lib?: string;
+        concurrency?: number;
+        batchSize?: number;
+        stopOnError?: boolean;
+        about?: boolean;
+    };
+    merge: {
+        s?: string[];
+        d?: string;
+        ignore?: string[];
+        format?: string;
+        stdout?: boolean;
+        noPath?: boolean;
+        pathAbove?: boolean;
+    };
+    migrate: {
+        interactive?: boolean;
+        codemod?: string;
+        project?: string;
+        mrTarget?: string;
+        dryRun?: boolean;
+        noBackup?: boolean;
+        consoleRelinkaInput?: string;
+        consoleRelinkaFrom?: string;
+        consoleRelinkaTo?: string;
+    };
+    mkdist: {
+        mkdistOnly?: boolean;
+        dev?: boolean;
+        dir?: string;
+        cwd?: string;
+        src?: string;
+        dist?: string;
+        clean?: boolean;
+        pattern?: string;
+        format?: string;
+        declaration?: boolean;
+        ext?: string;
+        jsx?: string;
+        jsxFactory?: string;
+        jsxFragment?: string;
+        loaders?: string;
+        minify?: boolean;
+        target?: string;
+    };
+    pack: {
+        input: string;
+        output?: string;
+        whitelabel?: string;
+        cdn?: string;
+        force?: boolean;
+        update?: boolean;
+        files?: string;
+        lastUpdate?: string;
+        unpack?: boolean;
+    };
+    pub: {
+        dev?: boolean;
+    };
+    remdn: {
+        mode?: "dirs-scan-only" | "dirs-scan-compare";
+        configPath?: string;
+        outputFilePath?: string;
+        initConfig?: string;
+    };
+    remove: {
+        action?: string;
+        name: string;
+        global?: boolean;
+        cwd?: string;
+        workspace?: boolean;
+        silent?: boolean;
+        linter?: boolean;
+        standalone?: boolean;
+    };
+    rempts: {
+        init?: string;
+        overwrite?: boolean;
+        customCmdsRoot?: string;
+        outFile?: string;
+        cmdDirs?: string[];
+    };
+    split: {
+        directory: string;
+        fileLineThreshold: number;
+        funcLineThreshold: number;
+    };
+    transform: {};
+    update: {
+        name?: string[];
+        ignore?: string[];
+        concurrency?: number;
+        linker?: "isolated" | "hoisted";
+        global?: boolean;
+        interactive?: boolean;
+    };
+    upgrade: {
+        interactive?: boolean;
+    };
+    x: {
+        action: string;
+        name?: string;
+        cwd?: string;
+        silent?: boolean;
+        target?: string;
+        timeout?: number;
+        throwOnError?: boolean;
+        args?: string;
+        global?: boolean;
+        yes?: boolean;
+        bun?: boolean;
+        npm?: boolean;
+        pnpm?: boolean;
+        yarn?: boolean;
+    };
+}
+export declare function loadTypedCommand<T extends keyof CommandArgsMap>(cmdName: T): Promise<Command>;
 export declare const getAggCmd: () => Promise<Command>;
 export declare const getBuildCmd: () => Promise<Command>;
+export declare const getBuildBinaryCmd: () => Promise<Command>;
 export declare const getCheckCmd: () => Promise<Command>;
 export declare const getConvCmd: () => Promise<Command>;
-export declare const getCopyCmd: () => Promise<Command>;
+export declare const getCreateCmd: () => Promise<Command>;
+export declare const getFsCmd: () => Promise<Command>;
+export declare const getGetCmd: () => Promise<Command>;
 export declare const getInitCmd: () => Promise<Command>;
 export declare const getInjectCmd: () => Promise<Command>;
+export declare const getInstallCmd: () => Promise<Command>;
 export declare const getLibsCmd: () => Promise<Command>;
+export declare const getMagicCmd: () => Promise<Command>;
 export declare const getMergeCmd: () => Promise<Command>;
 export declare const getMigrateCmd: () => Promise<Command>;
+export declare const getMkdistCmd: () => Promise<Command>;
+export declare const getPackCmd: () => Promise<Command>;
 export declare const getPubCmd: () => Promise<Command>;
+export declare const getRemdnCmd: () => Promise<Command>;
+export declare const getRemoveCmd: () => Promise<Command>;
 export declare const getRemptsCmd: () => Promise<Command>;
-export declare const getRenameCmd: () => Promise<Command>;
-export declare const getMagicCmd: () => Promise<Command>;
 export declare const getSplitCmd: () => Promise<Command>;
-export declare const getRmCmd: () => Promise<Command>;
+export declare const getTransformCmd: () => Promise<Command>;
 export declare const getUpdateCmd: () => Promise<Command>;
 export declare const getUpgradeCmd: () => Promise<Command>;
+export declare const getXCmd: () => Promise<Command>;
+export declare function callCmd<T extends keyof CommandArgsMap>(cmdName: T, args?: CommandArgsMap[T]): Promise<void>;
+export declare function getTypedCmd<T extends keyof CommandArgsMap>(cmdName: T): Promise<{
+    command: Command;
+    run: (args?: CommandArgsMap[T]) => Promise<void>;
+}>;
+export type { CommandArgsMap };

package/bin/app/cmds.js

@@ -1,19 +1,36 @@
-import { loadCommand } from "@reliverse/rempts";
-export const getAggCmd = async () => loadCommand("agg");
-export const getBuildCmd = async () => loadCommand("build");
-export const getCheckCmd = async () => loadCommand("check");
-export const getConvCmd = async () => loadCommand("conv");
-export const getCopyCmd = async () => loadCommand("copy");
-export const getInitCmd = async () => loadCommand("init");
-export const getInjectCmd = async () => loadCommand("inject");
-export const getLibsCmd = async () => loadCommand("libs");
-export const getMergeCmd = async () => loadCommand("merge");
-export const getMigrateCmd = async () => loadCommand("migrate");
-export const getPubCmd = async () => loadCommand("pub");
-export const getRemptsCmd = async () => loadCommand("rempts");
-export const getRenameCmd = async () => loadCommand("rename");
-export const getMagicCmd = async () => loadCommand("magic");
-export const getSplitCmd = async () => loadCommand("split");
-export const getRmCmd = async () => loadCommand("rm");
-export const getUpdateCmd = async () => loadCommand("update");
-export const getUpgradeCmd = async () => loadCommand("upgrade");
+import { loadCommand, callCmdImpl, getTypedCmdImpl } from "@reliverse/rempts";
+export async function loadTypedCommand(cmdName) {
+  return await loadCommand(cmdName);
+}
+export const getAggCmd = async () => loadTypedCommand("agg");
+export const getBuildCmd = async () => loadTypedCommand("build");
+export const getBuildBinaryCmd = async () => loadTypedCommand("build_binary");
+export const getCheckCmd = async () => loadTypedCommand("check");
+export const getConvCmd = async () => loadTypedCommand("conv");
+export const getCreateCmd = async () => loadTypedCommand("create");
+export const getFsCmd = async () => loadTypedCommand("fs");
+export const getGetCmd = async () => loadTypedCommand("get");
+export const getInitCmd = async () => loadTypedCommand("init");
+export const getInjectCmd = async () => loadTypedCommand("inject");
+export const getInstallCmd = async () => loadTypedCommand("install");
+export const getLibsCmd = async () => loadTypedCommand("libs");
+export const getMagicCmd = async () => loadTypedCommand("magic");
+export const getMergeCmd = async () => loadTypedCommand("merge");
+export const getMigrateCmd = async () => loadTypedCommand("migrate");
+export const getMkdistCmd = async () => loadTypedCommand("mkdist");
+export const getPackCmd = async () => loadTypedCommand("pack");
+export const getPubCmd = async () => loadTypedCommand("pub");
+export const getRemdnCmd = async () => loadTypedCommand("remdn");
+export const getRemoveCmd = async () => loadTypedCommand("remove");
+export const getRemptsCmd = async () => loadTypedCommand("rempts");
+export const getSplitCmd = async () => loadTypedCommand("split");
+export const getTransformCmd = async () => loadTypedCommand("transform");
+export const getUpdateCmd = async () => loadTypedCommand("update");
+export const getUpgradeCmd = async () => loadTypedCommand("upgrade");
+export const getXCmd = async () => loadTypedCommand("x");
+export async function callCmd(cmdName, args) {
+  await callCmdImpl(cmdName, args);
+}
+export async function getTypedCmd(cmdName) {
+  return await getTypedCmdImpl(cmdName);
+}

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

@@ -0,0 +1,18 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    mode: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    tool: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    update: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+export default _default;

package/bin/app/config/cmd.js

@@ -0,0 +1,43 @@
+import { relinka } from "@reliverse/relinka";
+import { defineArgs, defineCommand } from "@reliverse/rempts";
+import { ensureConfigMod } from "../../libs/sdk/sdk-impl/config/core.js";
+export default defineCommand({
+  meta: {
+    name: "config",
+    description: "Manage project-level and device-global configurations"
+  },
+  args: defineArgs({
+    mode: {
+      type: "string",
+      description: "Config mode: copy-remote, copy-internal",
+      default: "copy-remote"
+    },
+    tool: {
+      type: "string",
+      description: "Tool name (e.g., dler, rse)",
+      default: "dler"
+    },
+    update: {
+      type: "boolean",
+      description: "Force update existing configuration",
+      default: false
+    }
+  }),
+  run: async ({ args }) => {
+    const { mode, tool, update } = args;
+    try {
+      await ensureConfigMod({
+        tool,
+        mode,
+        forceUpdate: update
+      });
+      relinka("success", `Configuration for ${tool} has been ${update ? "updated" : "created"}`);
+    } catch (error) {
+      relinka(
+        "error",
+        `Failed to manage config: ${error instanceof Error ? error.message : String(error)}`
+      );
+      process.exit(1);
+    }
+  }
+});

package/bin/app/config/impl/typebox.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generates a JSON schema file from the TypeBox schema
+ */
+export declare function generateJsonSchema(typeboxSchema: any, outputPath: string): Promise<void>;
+/**
+ * Generates the schema.json in the project root
+ */
+export declare function generateSchemaFile(schema: any): Promise<void>;

package/bin/app/config/impl/typebox.js

@@ -0,0 +1,82 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+function convertTypeBoxToJsonSchema(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  if (schema.type === "string" && schema.enum) {
+    return {
+      type: "string",
+      enum: schema.enum
+    };
+  }
+  if (schema.anyOf || schema.allOf || schema.oneOf) {
+    const variants = schema.anyOf || schema.allOf || schema.oneOf;
+    const allLiterals = variants.every((v) => v.const !== void 0);
+    if (allLiterals) {
+      return {
+        type: "string",
+        enum: variants.map((v) => v.const)
+      };
+    }
+  }
+  if (schema.type === "object") {
+    const result = {
+      type: "object",
+      properties: {}
+    };
+    if (schema.required) {
+      result.required = schema.required;
+    }
+    if (schema.properties) {
+      for (const [key, value] of Object.entries(schema.properties)) {
+        result.properties[key] = convertTypeBoxToJsonSchema(value);
+      }
+    }
+    if (schema.additionalProperties) {
+      result.additionalProperties = convertTypeBoxToJsonSchema(schema.additionalProperties);
+    }
+    if (schema.patternProperties) {
+      result.patternProperties = {};
+      for (const [pattern, value] of Object.entries(schema.patternProperties)) {
+        result.patternProperties[pattern] = convertTypeBoxToJsonSchema(value);
+      }
+    }
+    return result;
+  }
+  if (schema.type === "array") {
+    return {
+      type: "array",
+      items: convertTypeBoxToJsonSchema(schema.items)
+    };
+  }
+  if (schema.type) {
+    const result = { type: schema.type };
+    if (schema.minimum !== void 0) result.minimum = schema.minimum;
+    if (schema.maximum !== void 0) result.maximum = schema.maximum;
+    if (schema.minLength !== void 0) result.minLength = schema.minLength;
+    if (schema.maxLength !== void 0) result.maxLength = schema.maxLength;
+    if (schema.pattern !== void 0) result.pattern = schema.pattern;
+    if (schema.format !== void 0) result.format = schema.format;
+    if (schema.default !== void 0) result.default = schema.default;
+    return result;
+  }
+  return schema;
+}
+export async function generateJsonSchema(typeboxSchema, outputPath) {
+  const converted = convertTypeBoxToJsonSchema(typeboxSchema);
+  const schema = {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    title: "rse configuration schema",
+    description: "https://docs.reliverse.org",
+    type: "object",
+    properties: converted.properties,
+    required: converted.required
+  };
+  await fs.writeFile(outputPath, JSON.stringify(schema, null, 2));
+}
+export async function generateSchemaFile(schema) {
+  const schemaPath = path.join(process.cwd(), "schema.json");
+  if (fs.existsSync(schemaPath)) {
+    await fs.remove(schemaPath);
+  }
+  await generateJsonSchema(schema, schemaPath);
+}

package/bin/app/mkdist/cmd.js

@@ -2,7 +2,7 @@ import { resolve } from "@reliverse/pathkit";
 import { defineArgs, defineCommand } from "@reliverse/rempts";
 import { dlerBuild } from "../build/impl.js";
 import { mkdist } from "../../libs/sdk/sdk-impl/build/providers/mkdist/mkdist-impl/make.js";
-import { ensureDlerConfig } from "../../libs/sdk/sdk-impl/config/init.js";
+import { ensureDlerConfig } from "../../libs/sdk/sdk-impl/config/prepare.js";
 export default defineCommand({
   meta: {
     name: "mkdist",

package/bin/app/pub/cmd.js

@@ -1,7 +1,7 @@
 import { defineArgs, defineCommand } from "@reliverse/rempts";
 import { dlerPub } from "./impl.js";
-import { ensureDlerConfig } from "../../libs/sdk/sdk-impl/config/init.js";
 import { getConfigDler } from "../../libs/sdk/sdk-impl/config/load.js";
+import { ensureDlerConfig } from "../../libs/sdk/sdk-impl/config/prepare.js";
 export default defineCommand({
   meta: {
     name: "pub",