@reliverse/dler 1.7.152 → 2.0.0

package/bin/impl/utils/codemods/convertToMonorepo.js

@@ -1,137 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { readPackageJSON, writePackageJSON } from "pkg-types";
-import { tsconfigJson } from "../../config/constants.js";
-const MONOREPO_CONFIGS = {
-  turborepo: {
-    "turbo.json": {
-      $schema: "https://turbo.build/schema.json",
-      globalDependencies: ["**/.env.*local"],
-      pipeline: {
-        build: {
-          dependsOn: ["^build"],
-          outputs: ["dist/**", ".next/**", "!.next/cache/**"]
-        },
-        lint: {},
-        dev: {
-          cache: false,
-          persistent: true
-        }
-      }
-    }
-  },
-  moonrepo: {
-    "moon.yml": `
-workspace:
-  extends: 'typescript'
-  projects:
-    - 'apps/*'
-    - 'packages/*'
-`
-  },
-  "bun-workspaces": {
-    "package.json": {
-      workspaces: ["apps/*", "packages/*"]
-    }
-  },
-  "pnpm-workspaces": {
-    "pnpm-workspace.yaml": `
-packages:
-  - 'apps/*'
-  - 'packages/*'
-`
-  }
-};
-export async function convertToMonorepo(projectPath, type, packages = [], sharedPackages = []) {
-  relinka("info", `Converting to ${type} monorepo in ${projectPath}`);
-  await fs.mkdir(path.join(projectPath, "apps"), { recursive: true });
-  await fs.mkdir(path.join(projectPath, "packages"), { recursive: true });
-  const packageJson = await readPackageJSON(path.join(projectPath, "package.json"));
-  if (!packageJson.workspaces) {
-    await fs.move(path.join(projectPath, "src"), path.join(projectPath, "apps", "web", "src"), {
-      overwrite: true
-    });
-    await fs.move(
-      path.join(projectPath, "package.json"),
-      path.join(projectPath, "apps", "web", "package.json"),
-      { overwrite: true }
-    );
-    const commonFiles = [
-      tsconfigJson,
-      "eslint.config.js",
-      ".prettierrc",
-      "next.config.js",
-      "postcss.config.js",
-      "tailwind.config.js"
-    ];
-    for (const file of commonFiles) {
-      if (await fs.pathExists(path.join(projectPath, file))) {
-        await fs.move(path.join(projectPath, file), path.join(projectPath, "apps", "web", file), {
-          overwrite: true
-        });
-      }
-    }
-  }
-  const rootPackageJson = {
-    name: `${packageJson.name}-monorepo`,
-    private: true,
-    scripts: {
-      build: type === "turborepo" ? "turbo run build" : "bun run --cwd apps/web build",
-      dev: type === "turborepo" ? "turbo run dev" : "bun run --cwd apps/web dev",
-      lint: type === "turborepo" ? "turbo run lint" : "bun run --cwd apps/web lint"
-    }
-  };
-  await writePackageJSON(path.join(projectPath, "package.json"), rootPackageJson);
-  const configs = MONOREPO_CONFIGS[type];
-  for (const [filename, content] of Object.entries(configs)) {
-    const filePath = path.join(projectPath, filename);
-    if (typeof content === "string") {
-      await fs.writeFile(filePath, content);
-    } else {
-      await fs.writeJSON(filePath, content, { spaces: 2 });
-    }
-  }
-  for (const pkg of packages) {
-    const pkgPath = path.join(projectPath, "apps", pkg);
-    await fs.mkdir(pkgPath, { recursive: true });
-    await writePackageJSON(path.join(pkgPath, "package.json"), {
-      name: `@${packageJson.name}/${pkg}`,
-      version: "0.0.0",
-      private: true
-    });
-  }
-  for (const pkg of sharedPackages) {
-    const pkgPath = path.join(projectPath, "packages", pkg);
-    await fs.mkdir(pkgPath, { recursive: true });
-    await writePackageJSON(path.join(pkgPath, "package.json"), {
-      name: `@${packageJson.name}/${pkg}`,
-      version: "0.0.0",
-      main: "./src/index.ts",
-      types: "./src/index.ts",
-      private: true
-    });
-    await fs.mkdir(path.join(pkgPath, "src"), { recursive: true });
-    await fs.writeFile(path.join(pkgPath, "src", "index.ts"), "export {};\n");
-  }
-  const rootTsConfig = {
-    compilerOptions: {
-      module: "esnext",
-      moduleResolution: "bundler",
-      target: "esnext",
-      lib: ["dom", "dom.iterable", "esnext"],
-      strict: true,
-      skipLibCheck: true,
-      jsx: "preserve"
-    },
-    references: [
-      { path: "apps/web" },
-      ...packages.map((pkg) => ({ path: `apps/${pkg}` })),
-      ...sharedPackages.map((pkg) => ({ path: `packages/${pkg}` }))
-    ]
-  };
-  await fs.writeJSON(path.join(projectPath, tsconfigJson), rootTsConfig, {
-    spaces: 2
-  });
-  relinka("success", `Converted to ${type} monorepo`);
-}

package/bin/impl/utils/codemods/removeComments.d.ts

@@ -1 +0,0 @@
-export declare function removeComments(cwd: string): Promise<void>;

package/bin/impl/utils/codemods/removeComments.js

@@ -1,13 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { glob } from "tinyglobby";
-export async function removeComments(cwd) {
-  const files = await glob("**/*.{js,jsx,ts,tsx}", { cwd });
-  for (const file of files) {
-    const content = await fs.readFile(path.join(cwd, file), "utf-8");
-    const withoutComments = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*/g, "").replace(/^\s*[\r\n]/gm, "");
-    await fs.writeFile(path.join(cwd, file), withoutComments);
-  }
-  relinka("success", "Removed comments from all TypeScript/JavaScript files");
-}

package/bin/impl/utils/codemods/removeUnusedDeps.d.ts

@@ -1 +0,0 @@
-export declare function getUnusedDependencies(cwd: string, ignoredDeps?: string[]): Promise<string[]>;

package/bin/impl/utils/codemods/removeUnusedDeps.js

@@ -1,29 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { destr } from "destr";
-import { glob } from "tinyglobby";
-export async function getUnusedDependencies(cwd, ignoredDeps = []) {
-  const packageJsonPath = path.join(cwd, "package.json");
-  const packageJson = destr(await fs.readFile(packageJsonPath, "utf-8"));
-  const allDeps = {
-    ...packageJson.dependencies ?? {},
-    ...packageJson.devDependencies ?? {}
-  };
-  const files = await glob("**/*.{js,jsx,ts,tsx}", { cwd });
-  const imports = /* @__PURE__ */ new Set();
-  for (const file of files) {
-    const content = await fs.readFile(path.join(cwd, file), "utf-8");
-    const importMatches = content.matchAll(/from ['"]([^'"]+)['"]/g);
-    for (const match of importMatches) {
-      const [, pkg] = match;
-      if (pkg && !pkg.startsWith(".") && !pkg.startsWith("~/")) {
-        imports.add(pkg.split("/")[0]);
-      }
-    }
-  }
-  return Object.keys(allDeps).filter(
-    (dep) => !imports.has(dep) && !ignoredDeps.some(
-      (pattern) => pattern.startsWith("/") ? new RegExp(pattern.slice(1, -1)).test(dep) : pattern === dep
-    )
-  );
-}

package/bin/impl/utils/codemods/replaceImportSymbol.d.ts

@@ -1 +0,0 @@
-export declare function replaceImportSymbol(projectPath: string, toSymbol: string): Promise<void>;

package/bin/impl/utils/codemods/replaceImportSymbol.js

@@ -1,57 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { glob } from "tinyglobby";
-async function detectCurrentImportSymbol(projectPath) {
-  const commonSymbols = ["@", "~", "#", "$", "@src", "@app"];
-  const files = await glob("**/*.{js,jsx,ts,tsx}", {
-    cwd: path.resolve(projectPath)
-  });
-  const symbolCounts = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const filePath = path.join(projectPath, file);
-    const content = await fs.readFile(filePath, "utf-8");
-    for (const symbol of commonSymbols) {
-      const importRegex = new RegExp(`(from|import)\\s+(['"])${symbol}/`, "g");
-      const matches = content.match(importRegex);
-      if (matches) {
-        symbolCounts.set(symbol, (symbolCounts.get(symbol) ?? 0) + matches.length);
-      }
-    }
-  }
-  let mostUsedSymbol = null;
-  let maxCount = 0;
-  symbolCounts.forEach((count, symbol) => {
-    if (count > maxCount) {
-      maxCount = count;
-      mostUsedSymbol = symbol;
-    }
-  });
-  return mostUsedSymbol;
-}
-export async function replaceImportSymbol(projectPath, toSymbol) {
-  const fromSymbol = await detectCurrentImportSymbol(projectPath);
-  if (!fromSymbol) {
-    relinka("warn", "No common import symbol detected in the project. No changes will be made.");
-    return;
-  }
-  relinka("info", `Replacing import symbol "${fromSymbol}" with "${toSymbol}" in ${projectPath}`);
-  const files = await glob("**/*.{js,jsx,ts,tsx}", {
-    cwd: path.resolve(projectPath)
-  });
-  for (const file of files) {
-    const filePath = path.join(projectPath, file);
-    const content = await fs.readFile(filePath, "utf-8");
-    const updatedContent = content.replace(
-      new RegExp(`from (['"])${fromSymbol}([^'"]*?)\\1`, "g"),
-      (_match, quote, path2) => `from ${quote}${toSymbol}${path2}${quote}`
-    ).replace(
-      new RegExp(`import (['"])${fromSymbol}([^'"]*?)\\1`, "g"),
-      (_match, quote, path2) => `import ${quote}${toSymbol}${path2}${quote}`
-    );
-    if (content !== updatedContent) {
-      await fs.writeFile(filePath, updatedContent, "utf-8");
-      relinka("info", `Updated imports in ${filePath}`);
-    }
-  }
-}

package/bin/impl/utils/codemods/replaceWithModern.d.ts

@@ -1 +0,0 @@
-export declare function replaceWithModern(projectPath: string): Promise<void>;

package/bin/impl/utils/codemods/replaceWithModern.js

@@ -1,122 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { glob } from "tinyglobby";
-const MODERN_REPLACEMENTS = [
-  // File System
-  {
-    pattern: /import fs from ["']fs["'];/g,
-    replacement: 'import fs from "@reliverse/relifso";',
-    description: "Replace Node.js fs with @reliverse/relifso"
-  },
-  {
-    pattern: /import \* as fs from ["']fs["'];/g,
-    replacement: 'import fs from "@reliverse/relifso";',
-    description: "Replace Node.js fs namespace with @reliverse/relifso"
-  },
-  {
-    pattern: /import \{ promises as fs \} from ["']fs["'];/g,
-    replacement: 'import fs from "@reliverse/relifso";',
-    description: "Replace fs.promises with @reliverse/relifso"
-  },
-  // Path
-  {
-    pattern: /import path from ["']path["'];/g,
-    replacement: 'import path from "@reliverse/pathkit";',
-    description: "Replace Node.js path with pathe"
-  },
-  {
-    pattern: /import \* as path from ["']path["'];/g,
-    replacement: 'import path from "@reliverse/pathkit";',
-    description: "Replace Node.js path namespace with pathe"
-  },
-  // HTTP/HTTPS
-  {
-    pattern: /import https? from ["']https?["'];/g,
-    replacement: 'import { fetch } from "undici";',
-    description: "Replace Node.js http/https with undici"
-  },
-  {
-    pattern: /import axios from ["']axios["'];/g,
-    replacement: 'import { fetch } from "undici";',
-    description: "Replace axios with undici"
-  },
-  // Process
-  {
-    pattern: /process\.env\./g,
-    replacement: "import.meta.env.",
-    description: "Replace process.env with import.meta.env"
-  },
-  {
-    pattern: /process\.cwd\(\)/g,
-    replacement: "import.meta.dir",
-    description: "Replace process.cwd() with import.meta.dir"
-  },
-  // URL
-  {
-    pattern: /import url from ["']url["'];/g,
-    replacement: '// Use URL and URLSearchParams globals instead of "url" module',
-    description: "Replace url module with URL globals"
-  },
-  // Console
-  {
-    pattern: /console\.(log|error|warn|info)/g,
-    replacement: "relinka",
-    description: "Replace console.* with relinka"
-  },
-  // Buffer
-  {
-    pattern: /import \{ Buffer \} from ["']buffer["'];/g,
-    replacement: "// Buffer is available globally",
-    description: "Remove Buffer import (globally available)"
-  },
-  // Events
-  {
-    pattern: /import \{ EventEmitter \} from ["']events["'];/g,
-    replacement: 'import { Emitter } from "mitt";',
-    description: "Replace EventEmitter with mitt"
-  }
-];
-export async function replaceWithModern(projectPath) {
-  relinka("info", "Starting modern replacements...");
-  const files = await glob("**/*.{js,ts,tsx}", {
-    cwd: projectPath,
-    absolute: true,
-    ignore: ["node_modules/**", "dist/**", ".next/**", "build/**", "coverage/**"]
-  });
-  let totalReplacements = 0;
-  const replacementsByFile = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    let content = await fs.readFile(file, "utf8");
-    let fileModified = false;
-    const fileReplacements = /* @__PURE__ */ new Set();
-    for (const { pattern, replacement, description } of MODERN_REPLACEMENTS) {
-      const originalContent = content;
-      content = content.replace(pattern, replacement);
-      if (content !== originalContent) {
-        fileModified = true;
-        totalReplacements++;
-        fileReplacements.add(description);
-      }
-    }
-    if (fileModified) {
-      await fs.writeFile(file, content, "utf8");
-      replacementsByFile.set(file, fileReplacements);
-      relinka("success", `Updated ${file}`);
-    }
-  }
-  if (totalReplacements > 0) {
-    relinka("info", "\nReplacement Summary:");
-    for (const [file, replacements] of replacementsByFile.entries()) {
-      relinka("info", `
-${path.relative(projectPath, file)}:`);
-      for (const description of replacements) {
-        relinka("info", `  - ${description}`);
-      }
-    }
-    relinka("success", `
-Completed ${totalReplacements} replacements.`);
-  } else {
-    relinka("info", "No replacements needed.");
-  }
-}

package/bin/impl/utils/comments.d.ts

@@ -1,6 +0,0 @@
-export type CommentStyle = "// " | "# " | "-- " | "/* " | "<!-- ";
-export type FileExtension = "js" | "jsx" | "ts" | "tsx" | "c" | "cpp" | "h" | "java" | "go" | "kt" | "swift" | "rs" | "cs" | "json" | "proto" | "dart" | "inc" | "pwn" | "py" | "rb" | "sh" | "pl" | "r" | "yml" | "yaml" | "sql" | "lua" | "css" | "scss" | "less" | "html" | "htm" | "xml" | "md";
-export type CommentMapping = Record<FileExtension, CommentStyle>;
-export declare const DEFAULT_COMMENT: "// ";
-export declare const COMMENT_MAP: CommentMapping;
-export declare const getCommentPrefix: (filePath: string, forceComment?: boolean, customComment?: string) => string;

package/bin/impl/utils/comments.js

@@ -1,41 +0,0 @@
-export const DEFAULT_COMMENT = "// ";
-const createCommentMapping = (extensions, comment) => Object.fromEntries(extensions.map((ext) => [ext, comment]));
-export const COMMENT_MAP = {
-  // Single-line comment style //
-  ...createCommentMapping(
-    [
-      "js",
-      "jsx",
-      "ts",
-      "tsx",
-      "c",
-      "cpp",
-      "h",
-      "java",
-      "go",
-      "kt",
-      "swift",
-      "rs",
-      "cs",
-      "json",
-      "proto",
-      "dart",
-      "inc",
-      "pwn"
-    ],
-    "// "
-  ),
-  // Single-line comment style #
-  ...createCommentMapping(["py", "rb", "sh", "pl", "r", "yml", "yaml"], "# "),
-  // Single-line comment style --
-  ...createCommentMapping(["sql", "lua"], "-- "),
-  // Multi-line comment style /* */
-  ...createCommentMapping(["css", "scss", "less"], "/* "),
-  // Multi-line comment style <!-- -->
-  ...createCommentMapping(["html", "htm", "xml", "md"], "<!-- ")
-};
-export const getCommentPrefix = (filePath, forceComment, customComment) => {
-  if (forceComment && customComment) return customComment;
-  const ext = filePath.split(".").pop()?.toLowerCase();
-  return COMMENT_MAP[ext] ?? customComment ?? DEFAULT_COMMENT;
-};

package/bin/impl/utils/common.d.ts

@@ -1,9 +0,0 @@
-import type { CommonCliArgs } from "../types/mod";
-export declare function commonStartActions({ cwdStr, isCI, isDev, showRuntimeInfo, clearConsole, withStartPrompt, }: CommonCliArgs & {
-    showRuntimeInfo: boolean;
-    clearConsole: boolean;
-    withStartPrompt: boolean;
-}): Promise<void>;
-export declare function commonEndActions({ withEndPrompt }: {
-    withEndPrompt: boolean;
-}): Promise<void>;

package/bin/impl/utils/common.js

@@ -1,37 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { prepareReliverseEnvironment } from "../config/prepare.js";
-import { showEndPrompt, showStartPrompt } from "./startEndPrompts.js";
-export async function commonStartActions({
-  cwdStr,
-  isCI,
-  isDev,
-  showRuntimeInfo,
-  clearConsole,
-  withStartPrompt
-}) {
-  if (!isCI && withStartPrompt) {
-    await showStartPrompt(isDev, showRuntimeInfo, clearConsole);
-  }
-  if (isDev) {
-    relinka.log("Running the CLI in dev mode.");
-  }
-  if (!process.versions.bun) {
-    relinka.warn(
-      "Rse CLI is currently optimized for Bun only. Unexpected behavior may occur with other runtimes."
-    );
-    relinka.warn("To avoid issues, it's strongly recommended to install Bun: https://bun.sh/get");
-  }
-  if (isCI) {
-    relinka.warn(
-      "To proceed in CI mode, use subcommands and their flags: rse --help OR rse <command> --help"
-    );
-    process.exit(0);
-  }
-  await prepareReliverseEnvironment(cwdStr, isDev, "ts");
-}
-export async function commonEndActions({ withEndPrompt }) {
-  if (withEndPrompt) {
-    await showEndPrompt();
-  }
-  process.exit(0);
-}

package/bin/impl/utils/createPackageJSON.d.ts

@@ -1,6 +0,0 @@
-/**
- * Creates a package.json file for a new project using pkg-types
- * @param projectPath Path where the package.json should be created
- * @param projectName Name of the project
- */
-export declare function createPackageJSON(projectPath: string, projectName: string, isLib: boolean): Promise<void>;

package/bin/impl/utils/createPackageJSON.js

@@ -1,20 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { definePackageJSON, writePackageJSON } from "pkg-types";
-export async function createPackageJSON(projectPath, projectName, isLib) {
-  const packageJson = definePackageJSON({
-    name: projectName,
-    version: "0.1.0",
-    description: `${projectName} is built with \u2764\uFE0F by @rse`,
-    type: "module",
-    ...isLib ? {} : { private: true }
-  });
-  const filename = "package.json";
-  const packageJsonPath = path.join(projectPath, filename);
-  await writePackageJSON(packageJsonPath, packageJson);
-  const content = await fs.readFile(packageJsonPath, "utf-8");
-  const formatted = JSON.stringify(JSON.parse(content), null, 2);
-  await fs.writeFile(packageJsonPath, formatted, "utf-8");
-  relinka("verbose", `Created ${filename} with ${isLib ? "library" : "application"} configuration`);
-}

package/bin/impl/utils/decideHelper.d.ts

@@ -1,12 +0,0 @@
-import type { ReliverseConfig } from "../schema/mod.js";
-/**
- * A string literal union for either 'gitBehavior' or 'deployBehavior'
- */
-type DecisionKey = "gitBehavior" | "deployBehavior";
-/**
- * This function handles the final "yes/no" decision, taking into account:
- * - The config's behavior key (autoYes, autoNo, prompt)
- * - Whether skipPrompts is true
- */
-export declare function decide(config: ReliverseConfig, behaviorKey: DecisionKey, title: string, content: string | undefined, defaultValue: boolean, skipPrompts: boolean): Promise<boolean>;
-export {};

package/bin/impl/utils/decideHelper.js

@@ -1,32 +0,0 @@
-import { relinka } from "@reliverse/relinka";
-import { confirmPrompt } from "@reliverse/rempts";
-export async function decide(config, behaviorKey, title, content, defaultValue, skipPrompts) {
-  try {
-    let behavior = config?.[behaviorKey] ?? "prompt";
-    if (skipPrompts && behavior === "prompt") {
-      behavior = "autoYes";
-    }
-    switch (behavior) {
-      case "autoYes":
-        relinka("verbose", `Auto-answering YES to: "${title}"`);
-        return true;
-      case "autoNo":
-        relinka("verbose", `Auto-answering NO to: "${title}"`);
-        return false;
-      // default is "prompt":
-      default:
-        return await confirmPrompt({
-          title,
-          content: content ?? "",
-          defaultValue
-        });
-    }
-  } catch (error) {
-    relinka(
-      "error",
-      "Failed to get decision:",
-      error instanceof Error ? error.message : String(error)
-    );
-    return defaultValue;
-  }
-}

package/bin/impl/utils/dependencies/getUserPkgManager.d.ts

@@ -1,13 +0,0 @@
-export type PackageManager = "npm" | "pnpm" | "yarn" | "bun";
-export type DetectionSource = "runtime" | "env" | "lockfile" | "config" | "default" | "system" | "global";
-export interface PkgManagerInfo {
-    packageManager: PackageManager;
-    source: DetectionSource;
-    version?: string;
-}
-export interface DetectOptions {
-    cwd?: string;
-    includeGlobalBun?: boolean;
-}
-export declare function getUserPkgManager(projectPath?: string, options?: DetectOptions): Promise<PkgManagerInfo>;
-export declare function getAllPkgManagers(projectPath: string, options?: DetectOptions): Promise<PkgManagerInfo[]>;