@reliverse/dler 1.7.92 → 1.7.93

package/bin/app/types/mod.js

@@ -0,0 +1,162 @@
+export { handleReplacements } from "../utils/replacements/reps-mod.js";
+export const DEFAULT_CONFIG_DLER = {
+  bumpDisable: false,
+  bumpFilter: ["package.json", "reliverse.ts"],
+  bumpMode: "patch",
+  bumpSet: "",
+  commonPubPause: true,
+  commonPubRegistry: "npm",
+  commonVerbose: false,
+  displayBuildPubLogs: true,
+  coreDeclarations: true,
+  coreDescription: "",
+  coreEntryFile: "mod.ts",
+  coreEntrySrcDir: "src",
+  coreBuildOutDir: "bin",
+  coreIsCLI: { enabled: false, scripts: {} },
+  distJsrAllowDirty: true,
+  distJsrBuilder: "jsr",
+  distJsrDirName: "dist-jsr",
+  distJsrDryRun: false,
+  distJsrFailOnWarn: false,
+  distJsrGenTsconfig: false,
+  distJsrOutFilesExt: "ts",
+  distJsrSlowTypes: true,
+  distNpmBuilder: "mkdist",
+  distNpmDirName: "dist-npm",
+  distNpmOutFilesExt: "js",
+  libsActMode: "main-project-only",
+  libsDirDist: "dist-libs",
+  libsDirSrc: "src/libs",
+  libsList: {},
+  logsFileName: ".logs/relinka.log",
+  logsFreshFile: true,
+  // Dependency filtering
+  filterDepsPatterns: {
+    global: ["@types", "biome", "eslint", "knip", "prettier", "typescript", "@reliverse/dler"],
+    "dist-npm": [],
+    "dist-jsr": [],
+    "dist-libs": {}
+  },
+  // Code quality tools
+  runBeforeBuild: [],
+  // tsc, eslint, biome, knip, dler-check
+  runAfterBuild: [],
+  // dler-check
+  // Build hooks
+  hooksBeforeBuild: [
+    // async () => {
+    //   await someAsyncOperation();
+    // }
+  ],
+  hooksAfterBuild: [
+    // async () => {
+    //   await someAsyncOperation();
+    // }
+  ],
+  postBuildSettings: {
+    deleteDistTmpAfterBuild: true
+  },
+  // Build setup
+  transpileFailOnWarn: false,
+  transpileEsbuild: "es2023",
+  transpileFormat: "esm",
+  transpileMinify: true,
+  transpilePublicPath: "/",
+  transpileSourcemap: "none",
+  transpileSplitting: false,
+  transpileStub: false,
+  transpileTarget: "node",
+  transpileWatch: false,
+  // Publish artifacts configuration
+  publishArtifacts: {
+    global: ["package.json", "README.md", "LICENSE"],
+    "dist-jsr": [],
+    "dist-npm": [],
+    "dist-libs": {}
+  },
+  // Files with these extensions will be built
+  // Any other files will be copied as-is to dist
+  buildPreExtensions: ["ts", "js"],
+  // If you need to exclude some ts/js files from being built,
+  // you can store them in the dirs with buildTemplatesDir name
+  buildTemplatesDir: "templates",
+  // Integrated relinka logger configuration
+  relinka: {
+    verbose: false,
+    dirs: {
+      maxLogFiles: 5
+    },
+    disableColors: false,
+    logFile: {
+      outputPath: "logs.log",
+      nameWithDate: "disable",
+      freshLogFile: true
+    },
+    saveLogsToFile: true,
+    timestamp: {
+      enabled: false,
+      format: "HH:mm:ss"
+    },
+    cleanupInterval: 1e4,
+    // 10 seconds
+    bufferSize: 4096,
+    // 4KB
+    maxBufferAge: 5e3,
+    // 5 seconds
+    levels: {
+      success: {
+        symbol: "\u2713",
+        fallbackSymbol: "[OK]",
+        color: "greenBright",
+        spacing: 3
+      },
+      info: {
+        symbol: "i",
+        fallbackSymbol: "[i]",
+        color: "cyanBright",
+        spacing: 3
+      },
+      error: {
+        symbol: "\u2716",
+        fallbackSymbol: "[ERR]",
+        color: "redBright",
+        spacing: 3
+      },
+      warn: {
+        symbol: "\u26A0",
+        fallbackSymbol: "[WARN]",
+        color: "yellowBright",
+        spacing: 3
+      },
+      fatal: {
+        symbol: "\u203C",
+        fallbackSymbol: "[FATAL]",
+        color: "redBright",
+        spacing: 3
+      },
+      verbose: {
+        symbol: "\u2727",
+        fallbackSymbol: "[VERBOSE]",
+        color: "gray",
+        spacing: 3
+      },
+      internal: {
+        symbol: "\u2699",
+        fallbackSymbol: "[INTERNAL]",
+        color: "magentaBright",
+        spacing: 3
+      },
+      log: { symbol: "\u2502", fallbackSymbol: "|", color: "dim", spacing: 3 },
+      message: {
+        symbol: "\u{1F7A0}",
+        fallbackSymbol: "[MSG]",
+        color: "cyan",
+        spacing: 3
+      }
+    }
+  }
+};
+export const defineConfig = (userConfig = {}) => {
+  return { ...DEFAULT_CONFIG_DLER, ...userConfig };
+};

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

@@ -0,0 +1,2 @@
+declare const _default: import("@reliverse/rempts").Command<import("@reliverse/rempts").EmptyArgs>;
+export default _default;

package/bin/app/update/cmd-2.js

@@ -0,0 +1,50 @@
+import { relinka } from "@reliverse/relinka";
+import { defineCommand, selectPrompt } from "@reliverse/rempts";
+import { execaCommand } from "execa";
+import { cliName } from "../config/constants.js";
+import { getAllPkgManagers } from "../utils/dependencies/getUserPkgManager.js";
+import { getCurrentWorkingDirectory } from "../utils/terminalHelpers.js";
+async function getPmOptions() {
+  const projectPath = getCurrentWorkingDirectory();
+  const detectedPMs = await getAllPkgManagers(projectPath);
+  const detectedPMMap = new Map(detectedPMs.map((pm) => [pm.packageManager, pm.source]));
+  const pmOptions = ["bun", "pnpm", "npm", "yarn"].map((pm) => {
+    const option = {
+      label: pm,
+      value: pm
+    };
+    const source = detectedPMMap.get(pm);
+    if (source && source !== "default") {
+      option.hint = "detected";
+    }
+    return option;
+  });
+  const defaultValue = [...detectedPMMap.keys()][0] ?? "npm";
+  return { pmOptions, defaultValue };
+}
+export default defineCommand({
+  meta: {
+    name: "update",
+    description: "Updates the CLI to the latest version",
+    hidden: false
+  },
+  run: async () => {
+    try {
+      const { pmOptions, defaultValue } = await getPmOptions();
+      const pm = await selectPrompt({
+        title: `Select a package manager to update the ${cliName}`,
+        options: pmOptions,
+        defaultValue
+      });
+      await execaCommand(`${pm} -g update --latest`, { stdio: "inherit" });
+      relinka("success", "Updated successfully!", "You can now use the latest `rse cli` version.");
+    } catch (error) {
+      relinka(
+        "error",
+        "Failed to update @rse",
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+    process.exit(0);
+  }
+});

package/bin/app/update/cmd.js

@@ -8,10 +8,10 @@ import pMap from "p-map";
 import { readPackageJSON } from "pkg-types";
 import semver from "semver";
 import { glob } from "tinyglobby";
-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";
+import { getConfigBunfig } from "../config/load.js";
+import { isCatalogSupported, updateCatalogs } from "../utils/pm/pm-catalog.js";
+import { detectPackageManager } from "../utils/pm/pm-detect.js";
+import { latestVersion } from "../utils/pm/pm-meta.js";
 const versionCache = /* @__PURE__ */ new Map();
 const CACHE_TTL = 5 * 60 * 1e3;
 function isNpmAlias(versionSpec) {
@@ -955,7 +955,7 @@ export default defineCommand({
         const otherPackageJsons = allPackageJsons.filter((p) => p !== rootPackageJsonPath);
         if (otherPackageJsons.length > 0) {
           relinka(
-            "info",
+            "verbose",
             `Found ${otherPackageJsons.length} additional package.json files to update recursively`
           );
           const recursiveUpdated = await updateWorkspacePackages(otherPackageJsons, args, options);
@@ -983,15 +983,15 @@ export default defineCommand({
       if (args.recursive) {
         const allPackageJsonCount = (await findAllPackageJsons(process.cwd())).length;
         relinka(
-          "success",
-          `Updated ${totalUpdated} dependencies across ${allPackageJsonCount} package.json files (recursive)`
+          "log",
+          `Updated ${totalUpdated} dependencies across ${allPackageJsonCount} package.json files`
         );
       } else {
         const isMonorepoProject = await isMonorepo(process.cwd());
         const shouldUpdateWorkspaces = args["all-workspaces"] || !args["root-only"] && isMonorepoProject;
         if (isMonorepoProject && shouldUpdateWorkspaces) {
           relinka(
-            "success",
+            "log",
             `Updated ${totalUpdated} dependencies across workspace (root + workspaces)`
           );
         } else if (isMonorepoProject) {
@@ -1004,8 +1004,12 @@ export default defineCommand({
       if (!args["with-install"]) {
         const installCommand = packageManager?.command || "your package manager";
         relinka(
-          "info",
-          `Skipped install step. Use --with-install to run '${installCommand} install'.`
+          "log",
+          `Install step is skipped by default. Run '${installCommand} install' manually to apply the changes.`
+        );
+        relinka(
+          "log",
+          `(experimental) Next time you can try --with-install flag to run it automatically.`
         );
         return;
       }

package/bin/app/update/migrate/cmd.js

@@ -5,8 +5,8 @@ import { defineArgs, defineCommand, multiselectPrompt } from "@reliverse/rempts"
 import { readPackageJSON } from "pkg-types";
 import semver from "semver";
 import { glob } from "tinyglobby";
-import { isCatalogSupported } from "../../../libs/sdk/sdk-impl/utils/pm/pm-catalog.js";
-import { detectPackageManager } from "../../../libs/sdk/sdk-impl/utils/pm/pm-detect.js";
+import { isCatalogSupported } from "../../utils/pm/pm-catalog.js";
+import { detectPackageManager } from "../../utils/pm/pm-detect.js";
 function isCatalogReference(versionSpec) {
   return versionSpec.startsWith("catalog:");
 }
@@ -218,15 +218,15 @@ async function removeCatalogFromRoot(rootPackageJsonPath) {
     const packageJsonContent = await fs.readFile(rootPackageJsonPath, "utf8");
     const packageJson = JSON.parse(packageJsonContent);
     if (packageJson.workspaces && !Array.isArray(packageJson.workspaces) && packageJson.workspaces.catalog) {
-      delete packageJson.workspaces.catalog;
+      packageJson.workspaces.catalog = void 0;
       if (Object.keys(packageJson.workspaces).length === 0 || Object.keys(packageJson.workspaces).length === 1 && packageJson.workspaces.packages) {
         if (!packageJson.workspaces.packages) {
-          delete packageJson.workspaces;
+          packageJson.workspaces = void 0;
         }
       }
     }
     if (packageJson.catalog) {
-      delete packageJson.catalog;
+      packageJson.catalog = void 0;
     }
     await fs.writeFile(rootPackageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf8");
   } catch (error) {
@@ -515,6 +515,7 @@ ${action.replace(/-/g, " ")} (${actionResults.length}):`);
     }
   }
   relinka("success", `Migration completed: ${results.length} changes made`);
+  relinka("log", "Run your package manager install command to apply the changes");
 }
 export default defineCommand({
   meta: {

package/bin/app/update/update-impl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@reliverse/rempts").Command<import("@reliverse/rempts").EmptyArgs>;
+export default _default;

package/bin/app/update/update-impl.js

@@ -0,0 +1,50 @@
+import { relinka } from "@reliverse/relinka";
+import { defineCommand, selectPrompt } from "@reliverse/rempts";
+import { execaCommand } from "execa";
+import { cliName } from "../config/constants.js";
+import { getAllPkgManagers } from "../utils/dependencies/getUserPkgManager.js";
+import { getCurrentWorkingDirectory } from "../utils/terminalHelpers.js";
+async function getPmOptions() {
+  const projectPath = getCurrentWorkingDirectory();
+  const detectedPMs = await getAllPkgManagers(projectPath);
+  const detectedPMMap = new Map(detectedPMs.map((pm) => [pm.packageManager, pm.source]));
+  const pmOptions = ["bun", "pnpm", "npm", "yarn"].map((pm) => {
+    const option = {
+      label: pm,
+      value: pm
+    };
+    const source = detectedPMMap.get(pm);
+    if (source && source !== "default") {
+      option.hint = "detected";
+    }
+    return option;
+  });
+  const defaultValue = [...detectedPMMap.keys()][0] ?? "npm";
+  return { pmOptions, defaultValue };
+}
+export default defineCommand({
+  meta: {
+    name: "update",
+    description: "Updates the CLI to the latest version",
+    hidden: false
+  },
+  run: async () => {
+    try {
+      const { pmOptions, defaultValue } = await getPmOptions();
+      const pm = await selectPrompt({
+        title: `Select a package manager to update the ${cliName}`,
+        options: pmOptions,
+        defaultValue
+      });
+      await execaCommand(`${pm} -g update --latest`, { stdio: "inherit" });
+      relinka("success", "Updated successfully!", "You can now use the latest `rse cli` version.");
+    } catch (error) {
+      relinka(
+        "error",
+        "Failed to update @rse",
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+    process.exit(0);
+  }
+});

package/bin/app/upgrade/cmd.js

@@ -3,8 +3,8 @@ import { relinka } from "@reliverse/relinka";
 import { defineArgs, defineCommand, multiselectPrompt } from "@reliverse/rempts";
 import { lookpath } from "lookpath";
 import { readPackageJSON } from "pkg-types";
-import { x } from "../../libs/sdk/sdk-impl/utils/exec/exec-mod.js";
-import { detectPackageManager } from "../../libs/sdk/sdk-impl/utils/pm/pm-detect.js";
+import { x } from "../utils/exec/exec-mod.js";
+import { detectPackageManager } from "../utils/pm/pm-detect.js";
 export default defineCommand({
   meta: {
     name: "upgrade",

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

@@ -0,0 +1,17 @@
+declare const _default: import("@reliverse/rempts").Command<{
+    files: {
+        type: "positional";
+        required: true;
+        description: string;
+    };
+    provider: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    dryRun: {
+        type: "boolean";
+        description: string;
+    };
+}>;
+export default _default;

package/bin/app/upload/cmd.js

@@ -0,0 +1,67 @@
+import fs from "node:fs/promises";
+import { relinka } from "@reliverse/relinka";
+import { defineCommand } from "@reliverse/rempts";
+import ora from "ora";
+import { readFilesFromPaths, uploadToProvider } from "./providers/providers-mod.js";
+import { formatBytes } from "./upload-utils.js";
+export default defineCommand({
+  meta: {
+    name: "upload",
+    description: "Upload files to a cloud storage provider"
+  },
+  args: {
+    files: {
+      type: "positional",
+      required: true,
+      description: "List of files to upload"
+    },
+    provider: {
+      type: "string",
+      alias: "p",
+      description: "Which provider to use (uploadthing|uploadcare)"
+    },
+    dryRun: {
+      type: "boolean",
+      description: "Simulate upload without actually sending files"
+    }
+  },
+  run: async ({ args }) => {
+    relinka("verbose", "args", String(args));
+    const spinner = ora("Validating files...").start();
+    try {
+      const inputFiles = Array.isArray(args.files) ? args.files : [args.files];
+      const validFiles = await Promise.all(
+        inputFiles.map(async (filePath) => {
+          const exists = await fs.access(filePath).then(() => true).catch(() => false);
+          if (!exists) relinka("error", `File not found: ${filePath}`);
+          return exists ? filePath : null;
+        })
+      ).then((results2) => results2.filter((path) => path !== null));
+      if (validFiles.length === 0) {
+        spinner.fail("No valid files found!");
+        return;
+      }
+      if (args.dryRun) {
+        spinner.succeed("Dry run complete. No files uploaded.");
+        return;
+      }
+      spinner.text = "Uploading...";
+      const fileObjs = await readFilesFromPaths(validFiles);
+      const results = await uploadToProvider(fileObjs, args.provider);
+      spinner.succeed("Upload completed!");
+      relinka("info", "\nUpload Results:");
+      results.forEach((res) => {
+        relinka("info", `File: ${res.name}`);
+        relinka("info", `URL: ${res.url}`);
+        if (res.key) relinka("info", `Key: ${res.key}`);
+        if (res.uuid) relinka("info", `UUID: ${res.uuid}`);
+        relinka("info", `Size: ${formatBytes(res.size)}
+`);
+      });
+    } catch (error) {
+      spinner.fail("Upload failed");
+      relinka("error", String(error));
+      process.exit(1);
+    }
+  }
+});

package/bin/app/upload/providers/providers-mod.d.ts

@@ -0,0 +1,20 @@
+import type { Buffer } from "buffer";
+export interface UploadFile {
+    name: string;
+    data: Buffer;
+    type: string;
+}
+export interface UploadResult {
+    url: string;
+    size: number;
+    name: string;
+    uuid?: string;
+    key?: string;
+}
+export declare function uploadToProvider(files: UploadFile[], provider?: string): Promise<UploadResult[]>;
+export declare function getMimeType(filePath: string): string;
+export declare function readFilesFromPaths(filePaths: string[]): Promise<{
+    name: string;
+    data: any;
+    type: string;
+}[]>;

package/bin/app/upload/providers/providers-mod.js

@@ -0,0 +1,40 @@
+import fs from "node:fs/promises";
+import path from "@reliverse/pathkit";
+import { uploadToUploadcare } from "./uploadcare.js";
+import { uploadToUploadthing } from "./uploadthing.js";
+export async function uploadToProvider(files, provider) {
+  const defaultProvider = process.env.DEFAULT_UPLOAD_PROVIDER || "uploadthing";
+  const chosen = provider || defaultProvider;
+  switch (chosen) {
+    case "uploadcare":
+      return uploadToUploadcare(files);
+    case "uploadthing":
+      return uploadToUploadthing(files);
+    default:
+      throw new Error(`Unsupported provider: ${chosen}`);
+  }
+}
+export function getMimeType(filePath) {
+  const extension = path.extname(filePath).toLowerCase();
+  const mimeTypes = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".pdf": "application/pdf",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".txt": "text/plain"
+  };
+  return mimeTypes[extension] || "application/octet-stream";
+}
+export async function readFilesFromPaths(filePaths) {
+  return Promise.all(
+    filePaths.map(async (filePath) => {
+      const data = await fs.readFile(filePath);
+      const name = path.basename(filePath);
+      const type = getMimeType(filePath);
+      return { name, data, type };
+    })
+  );
+}

package/bin/app/upload/providers/uploadcare.d.ts

@@ -0,0 +1,13 @@
+export interface UploadedUCFile {
+    name: string;
+    data: Buffer;
+    type: string;
+}
+interface UCResult {
+    url: string;
+    uuid: string;
+    size: number;
+    name: string;
+}
+export declare function uploadToUploadcare(files: UploadedUCFile[]): Promise<UCResult[]>;
+export {};

package/bin/app/upload/providers/uploadcare.js

@@ -0,0 +1,26 @@
+import { uploadDirect } from "@uploadcare/upload-client";
+export async function uploadToUploadcare(files) {
+  const publicKey = process.env.UPLOADCARE_PUBLIC_KEY;
+  if (!publicKey) {
+    throw new Error("Missing UPLOADCARE_PUBLIC_KEY");
+  }
+  const results = [];
+  for (const file of files) {
+    const uploadResponse = await uploadDirect(file.data, {
+      publicKey,
+      store: "auto",
+      fileName: file.name,
+      contentType: file.type
+      // onProgress: ({ isComputable, value }) => {
+      // TODO: progress handling
+      // },
+    });
+    results.push({
+      url: `https://ucarecdn.com/${uploadResponse.uuid}/`,
+      uuid: uploadResponse.uuid,
+      size: uploadResponse.size,
+      name: file.name
+    });
+  }
+  return results;
+}

package/bin/app/upload/providers/uploadthing.d.ts

@@ -0,0 +1,11 @@
+export interface UploadedFile {
+    name: string;
+    data: Buffer;
+    type: string;
+}
+export declare function uploadToUploadthing(files: UploadedFile[]): Promise<{
+    url: string;
+    key: string;
+    size: number;
+    name: string;
+}[]>;

package/bin/app/upload/providers/uploadthing.js

@@ -0,0 +1,31 @@
+import { UTApi } from "uploadthing/server";
+export async function uploadToUploadthing(files) {
+  const apiKey = process.env.UPLOADTHING_API_KEY;
+  if (!apiKey) {
+    throw new Error("Missing UPLOADTHING_API_KEY");
+  }
+  const utapi = new UTApi({ token: apiKey });
+  const results = [];
+  for (const file of files) {
+    const blob = new Blob([file.data], { type: file.type });
+    const fileEsque = Object.assign(blob, {
+      name: file.name,
+      lastModified: Date.now()
+    });
+    const res = await utapi.uploadFiles(fileEsque);
+    const uploadedFile = res;
+    if (!uploadedFile.data) {
+      throw new Error("Failed to upload file");
+    }
+    results.push({
+      // @ts-expect-error TODO fix ts
+      url: res.data.ufsUrl,
+      // @ts-expect-error TODO fix ts
+      key: res.data.key,
+      // @ts-expect-error TODO fix ts
+      size: res.data.size,
+      name: file.name
+    });
+  }
+  return results;
+}

package/bin/app/upload/upload-utils.d.ts

@@ -0,0 +1 @@
+export declare function formatBytes(bytes: number): string;

package/bin/app/upload/upload-utils.js

@@ -0,0 +1,7 @@
+export function formatBytes(bytes) {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}