@reliverse/dler 1.7.153 → 2.0.0

package/bin/impl/utils/replacements/reps-impl.d.ts

@@ -1,35 +0,0 @@
-/**
- * Utility to extract author and project name from template URL
- */
-export declare function extractRepoInfo(templateUrl: string): {
-    inputRepoAuthor: string;
-    inputRepoName: string;
-};
-export interface ReplaceConfig {
-    fileExtensions?: string[];
-    excludedDirs?: string[];
-    stringExclusions?: string[];
-    verbose?: boolean;
-    dryRun?: boolean;
-    skipBinaryFiles?: boolean;
-    maxConcurrency?: number;
-    stopOnError?: boolean;
-}
-/**
- * Replaces specified strings in files under a target directory.
- * Supports concurrent processing, binary file detection, and dry runs.
- *
- * @param projectPath - Root directory to process files in
- * @param oldValues - Map of strings to replace (key) with their replacements (value)
- * @param config - Optional configuration for file processing:
- *   - fileExtensions: File types to process (e.g., [".js", ".ts"])
- *   - excludedDirs: Directories to skip (e.g., ["node_modules"])
- *   - stringExclusions: Strings to never replace
- *   - verbose: Enable detailed logging
- *   - dryRun: Preview changes without writing
- *   - skipBinaryFiles: Skip processing of binary files
- *   - maxConcurrency: Limit parallel processing
- *   - stopOnError: Stop on first error
- * @throws Error if target directory doesn't exist or processing fails
- */
-export declare function replaceStringsInFiles(projectPath: string, oldValues: Record<string, string>, config?: ReplaceConfig): Promise<void>;

package/bin/impl/utils/replacements/reps-impl.js

@@ -1,220 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import escapeStringRegexp from "escape-string-regexp";
-export function extractRepoInfo(templateUrl) {
-  const formattedTemplateUrl = templateUrl.startsWith("github:") ? templateUrl : `github:${templateUrl}`;
-  const match = /^github:(?:https?:\/\/github\.com\/)?([^/]+)\/([^/]+)/.exec(formattedTemplateUrl);
-  if (!match) {
-    return { inputRepoAuthor: "", inputRepoName: "" };
-  }
-  const [, repoAuthor, repoName] = match;
-  const inputRepoAuthor = repoAuthor ?? "";
-  const inputRepoName = repoName?.replace(".git", "") ?? "";
-  return {
-    inputRepoAuthor,
-    inputRepoName
-  };
-}
-function looksLikeBinary(buffer, size) {
-  for (let i = 0; i < size; i++) {
-    if (buffer[i] === 0) return true;
-  }
-  return false;
-}
-async function isBinaryFile(filePath, chunkSize = 1e3) {
-  const fd = await fs.open(filePath, "r");
-  try {
-    const buffer = Buffer.alloc(chunkSize);
-    const { bytesRead } = await fd.read(buffer, 0, chunkSize, 0);
-    return looksLikeBinary(buffer, bytesRead);
-  } finally {
-    await fd.close();
-  }
-}
-async function gatherAllFiles(dir, shouldSkipDir) {
-  const filesInDir = await fs.readdir(dir);
-  const result = [];
-  for (const file of filesInDir) {
-    const fullPath = path.join(dir, file);
-    const stat = await fs.lstat(fullPath);
-    if (stat.isDirectory()) {
-      if (!shouldSkipDir(file)) {
-        const nested = await gatherAllFiles(fullPath, shouldSkipDir);
-        result.push(...nested);
-      }
-    } else {
-      result.push(fullPath);
-    }
-  }
-  return result;
-}
-async function runWithConcurrency(items, concurrency, taskFn, stopOnError) {
-  return new Promise((resolve, reject) => {
-    let index = 0;
-    let active = 0;
-    let isRejected = false;
-    let completedCount = 0;
-    const next = () => {
-      if (isRejected) return;
-      if (completedCount === items.length) {
-        return resolve();
-      }
-      while (active < concurrency && index < items.length) {
-        const currentItem = items[index];
-        if (currentItem === void 0) {
-          index++;
-          continue;
-        }
-        active++;
-        index++;
-        taskFn(currentItem).catch((err) => {
-          if (stopOnError) {
-            isRejected = true;
-            return reject(err instanceof Error ? err : new Error(String(err)));
-          } else {
-            relinka("error", `Error processing item: ${String(err)}`);
-          }
-        }).finally(() => {
-          active--;
-          completedCount++;
-          next();
-        });
-      }
-    };
-    next();
-  });
-}
-export async function replaceStringsInFiles(projectPath, oldValues, config = {}) {
-  if (!projectPath || typeof projectPath !== "string") {
-    throw new Error("Target directory is required and must be a string");
-  }
-  if (!oldValues || typeof oldValues !== "object") {
-    throw new Error("oldValues must be a non-null object");
-  }
-  const {
-    fileExtensions = [
-      ".js",
-      ".ts",
-      ".json",
-      ".md",
-      ".mdx",
-      ".html",
-      ".jsx",
-      ".tsx",
-      ".css",
-      ".scss",
-      ".mjs",
-      ".cjs"
-    ],
-    excludedDirs = [
-      "node_modules",
-      ".git",
-      "build",
-      ".next",
-      "dist",
-      "dist-jsr",
-      "dist-npm",
-      "coverage"
-    ],
-    stringExclusions = [
-      "https://api.github.com/repos/blefnk/relivator",
-      "https://api.github.com/repos/blefnk/relivator-nextjs-template",
-      "https://api.github.com/repos/blefnk/versator",
-      "https://api.github.com/repos/blefnk/versator-nextjs-template"
-    ],
-    verbose = false,
-    dryRun = false,
-    skipBinaryFiles = false,
-    maxConcurrency = 8,
-    stopOnError = false
-  } = config;
-  const exactFileNames = /* @__PURE__ */ new Set();
-  const extensionSet = /* @__PURE__ */ new Set();
-  for (const pattern of fileExtensions) {
-    if (pattern.startsWith(".")) {
-      extensionSet.add(pattern.toLowerCase());
-    } else {
-      exactFileNames.add(pattern.toLowerCase());
-    }
-  }
-  function shouldProcessFile(filePath) {
-    const base = path.basename(filePath).toLowerCase();
-    const ext = path.extname(base).toLowerCase();
-    if (exactFileNames.has(base)) {
-      return true;
-    }
-    return extensionSet.has(ext);
-  }
-  function shouldSkipDirectory(dirName) {
-    return excludedDirs.includes(dirName);
-  }
-  async function replaceInFile(filePath) {
-    try {
-      if (skipBinaryFiles && await isBinaryFile(filePath)) {
-        if (verbose) {
-          relinka("verbose", `Skipping binary file: ${filePath}`);
-        }
-        return;
-      }
-      const fileContent = await fs.readFile(filePath, "utf8");
-      let newContent = fileContent;
-      let hasChanges = false;
-      const changesMade = [];
-      for (const [key, value] of Object.entries(oldValues)) {
-        if (!key || !value || stringExclusions.includes(key)) continue;
-        const safeKey = escapeStringRegexp(key);
-        const regex = new RegExp(safeKey, "g");
-        let localChangeCount = 0;
-        newContent = newContent.replace(regex, (_match) => {
-          hasChanges = true;
-          localChangeCount++;
-          return value;
-        });
-        if (localChangeCount > 0) {
-          changesMade.push(`${key} => ${value} (${localChangeCount}x)`);
-        }
-      }
-      if (hasChanges) {
-        if (!dryRun) {
-          await fs.writeFile(filePath, newContent, "utf8");
-        }
-        if (verbose) {
-          const relativePath = path.relative(projectPath, filePath);
-          relinka("verbose", `Updated ${relativePath}:`);
-          changesMade.forEach((c) => relinka("verbose", `  - ${c}`));
-        } else {
-          if (verbose) {
-            relinka("verbose", `Updated strings in ${filePath}`);
-          }
-        }
-      }
-    } catch (error) {
-      throw new Error(`Error processing file ${filePath}: ${String(error)}`);
-    }
-  }
-  const errors = [];
-  const exists = await fs.pathExists(projectPath);
-  if (!exists) {
-    throw new Error(`Target directory does not exist: ${projectPath}`);
-  }
-  let allFiles = [];
-  try {
-    allFiles = await gatherAllFiles(projectPath, shouldSkipDirectory);
-  } catch (err) {
-    const e = `Error reading directory structure: ${String(err)}`;
-    errors.push(e);
-    relinka("error", e);
-  }
-  const targetFiles = allFiles.filter((filePath) => shouldProcessFile(filePath));
-  try {
-    await runWithConcurrency(targetFiles, maxConcurrency, replaceInFile, stopOnError);
-  } catch (err) {
-    errors.push(String(err));
-  }
-  if (errors.length > 0) {
-    relinka("error", `Some files could not be processed:
-${errors.join(", ")}`);
-    throw new Error("Failed to replace strings in some files.");
-  }
-}

package/bin/impl/utils/replacements/reps-keys.d.ts

@@ -1,16 +0,0 @@
-export interface Hardcoded {
-    RelivatorTitle: "Relivator template is the foundation of your eCommerce platform: Build More Efficient, Engaging, and Profitable Online Stores";
-    RelivatorShort: "Relivator";
-    RelivatorLower: "relivator";
-    RelivatorDomain: "relivator.com";
-    DefaultAuthor: "blefnk";
-    DefaultEmail: "onboarding@resend.dev";
-    GeneralTemplate: "template";
-}
-export interface UrlPatterns {
-    githubUrl: (author: string, repo: string) => string;
-    vercelUrl: (project: string) => string;
-    packageName: (name: string) => string;
-}
-export declare const HardcodedStrings: Hardcoded;
-export declare const CommonPatterns: UrlPatterns;

package/bin/impl/utils/replacements/reps-keys.js

@@ -1,14 +0,0 @@
-export const HardcodedStrings = {
-  RelivatorTitle: "Relivator template is the foundation of your eCommerce platform: Build More Efficient, Engaging, and Profitable Online Stores",
-  RelivatorShort: "Relivator",
-  RelivatorLower: "relivator",
-  RelivatorDomain: "relivator.com",
-  DefaultAuthor: "blefnk",
-  DefaultEmail: "onboarding@resend.dev",
-  GeneralTemplate: "template"
-};
-export const CommonPatterns = {
-  githubUrl: (author, repo) => `https://github.com/${author}/${repo}`,
-  vercelUrl: (project) => `${project}.vercel.app`,
-  packageName: (name) => `@${name}/app`
-};

package/bin/impl/utils/replacements/reps-mod.d.ts

@@ -1,5 +0,0 @@
-import type { ProjectConfigReturn } from "../../types/mod.js";
-import type { RepoOption } from "../projectRepository.js";
-export declare function handleReplacements(projectPath: string, selectedRepo: RepoOption, externalrseth: string, config: ProjectConfigReturn & {
-    projectDescription?: string;
-}, existingRepo: boolean, showSuccessMessage: boolean, isTemplateDownload: boolean): Promise<void>;

package/bin/impl/utils/replacements/reps-mod.js

@@ -1,211 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { destr } from "destr";
-import { readPackageJSON } from "pkg-types";
-import { glob } from "tinyglobby";
-import { extractRepoInfo, replaceStringsInFiles } from "./reps-impl.js";
-import { CommonPatterns, HardcodedStrings } from "./reps-keys.js";
-async function getPackageNames(projectPath) {
-  try {
-    const pkgPath = path.join(projectPath, "package.json");
-    if (!await fs.pathExists(pkgPath)) return [];
-    const pkg = await readPackageJSON(pkgPath);
-    const allDeps = {
-      ...pkg.dependencies || {},
-      ...pkg.devDependencies || {},
-      ...pkg.peerDependencies || {}
-    };
-    return Object.keys(allDeps);
-  } catch (error) {
-    relinka("warn", "Failed to read package.json:", String(error));
-    return [];
-  }
-}
-async function getImportPaths(projectPath) {
-  const importPaths = /* @__PURE__ */ new Set();
-  try {
-    const files = await glob("**/*.{js,ts,jsx,tsx}", {
-      cwd: projectPath,
-      ignore: ["node_modules/**", "dist/**", ".next/**", "build/**"]
-    });
-    for (const file of files) {
-      const content = await fs.readFile(path.join(projectPath, file), "utf-8");
-      const importMatches = [
-        ...content.matchAll(/(?:import|from)\s+['"]([^'"]+)['"]/g),
-        ...content.matchAll(/import\(['"]([^'"]+)['"]\)/g)
-      ];
-      for (const match of importMatches) {
-        const importPath = match[1];
-        if (importPath && !importPath.startsWith(".")) {
-          importPaths.add(importPath);
-        }
-      }
-    }
-  } catch (error) {
-    relinka("warn", "Failed to gather import paths:", String(error));
-  }
-  return [...importPaths];
-}
-async function getRepositoryUrl(projectPath) {
-  try {
-    const pkgPath = path.join(projectPath, "package.json");
-    if (!await fs.pathExists(pkgPath)) return "";
-    const pkg = await readPackageJSON(pkgPath);
-    if (pkg.repository) {
-      if (typeof pkg.repository === "string") {
-        if (!pkg.repository.includes("://")) {
-          return `https://github.com/${pkg.repository}`;
-        }
-        return pkg.repository;
-      }
-      if (typeof pkg.repository === "object" && pkg.repository.url) {
-        return pkg.repository.url;
-      }
-    }
-    if (pkg.name?.startsWith("@")) {
-      const [scope, name] = pkg.name.slice(1).split("/");
-      return `https://github.com/${scope}/${name}`;
-    }
-    return "";
-  } catch (error) {
-    relinka("warn", "Failed to read package.json:", String(error));
-    return "";
-  }
-}
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-function capitalizeWithDashes(str) {
-  return str.split("-").map((word) => capitalize(word)).join(" ");
-}
-function createCaseVariations(oldValue, newValue) {
-  return {
-    [oldValue.toLowerCase()]: newValue.toLowerCase(),
-    [capitalize(oldValue)]: capitalize(newValue),
-    [oldValue.toUpperCase()]: newValue.toUpperCase(),
-    [capitalizeWithDashes(oldValue)]: capitalizeWithDashes(newValue)
-  };
-}
-export async function handleReplacements(projectPath, selectedRepo, externalrseth, config, existingRepo, showSuccessMessage, isTemplateDownload) {
-  const term = isTemplateDownload ? "template" : "repo";
-  relinka("verbose", "Personalizing texts in the initialized files...");
-  const [packageNames, importPaths] = await Promise.all([
-    getPackageNames(projectPath),
-    getImportPaths(projectPath)
-  ]);
-  let externalConfig;
-  if (existingRepo && externalrseth && await fs.pathExists(externalrseth)) {
-    try {
-      const externalConfigContent = await fs.readFile(externalrseth, "utf-8");
-      const parsed = destr(externalConfigContent);
-      if (parsed && typeof parsed === "object") {
-        externalConfig = parsed;
-        relinka(
-          "info",
-          "Found external config from existing repo, will use its values for replacements"
-        );
-      }
-    } catch (error) {
-      relinka("warn", "Failed to parse external config:", String(error));
-    }
-  }
-  const { inputRepoAuthor, inputRepoName } = extractRepoInfo(selectedRepo);
-  let templateUrl = await getRepositoryUrl(projectPath);
-  if (!templateUrl) {
-    templateUrl = HardcodedStrings.RelivatorDomain;
-  }
-  const replacementsMap = {
-    ...createCaseVariations(HardcodedStrings.GeneralTemplate, "project"),
-    [HardcodedStrings.RelivatorDomain]: config.primaryDomain,
-    [templateUrl]: config.primaryDomain,
-    [`${inputRepoName}.vercel.app`]: `${config.projectName}.vercel.app`,
-    ...createCaseVariations(inputRepoName, config.projectName),
-    ...createCaseVariations(HardcodedStrings.RelivatorShort, config.projectName),
-    ...createCaseVariations(inputRepoAuthor, config.frontendUsername),
-    ...createCaseVariations(HardcodedStrings.DefaultAuthor, config.frontendUsername),
-    [CommonPatterns.githubUrl(inputRepoAuthor, inputRepoName)]: CommonPatterns.githubUrl(
-      config.frontendUsername,
-      config.projectName
-    ),
-    [CommonPatterns.githubUrl(HardcodedStrings.DefaultAuthor, HardcodedStrings.RelivatorLower)]: CommonPatterns.githubUrl(config.frontendUsername, config.projectName),
-    [CommonPatterns.packageName(inputRepoName)]: CommonPatterns.packageName(config.projectName),
-    [CommonPatterns.packageName(HardcodedStrings.RelivatorLower)]: CommonPatterns.packageName(
-      config.projectName
-    ),
-    [HardcodedStrings.RelivatorTitle]: config.projectDescription ? `${capitalizeWithDashes(config.projectName)} - ${config.projectDescription}` : `${capitalizeWithDashes(config.projectName)} - A modern web application for your business needs`,
-    [HardcodedStrings.DefaultEmail]: config.frontendUsername.includes("@") ? config.frontendUsername : `${config.frontendUsername}@${config.primaryDomain}`
-  };
-  if (externalConfig) {
-    if (externalConfig.projectName && externalConfig.projectName !== config.projectName) {
-      replacementsMap[externalConfig.projectName] = config.projectName;
-      replacementsMap[externalConfig.projectName.toLowerCase()] = config.projectName.toLowerCase();
-      replacementsMap[capitalize(externalConfig.projectName)] = capitalizeWithDashes(
-        config.projectName
-      );
-    }
-    if (externalConfig.projectAuthor && externalConfig.projectAuthor !== config.frontendUsername) {
-      replacementsMap[externalConfig.projectAuthor] = config.frontendUsername;
-    }
-    if (externalConfig.projectDescription) {
-      replacementsMap[externalConfig.projectDescription] = config.projectDescription ?? "";
-    }
-  }
-  const validReplacements = Object.fromEntries(
-    Object.entries(replacementsMap).filter(
-      ([key, value]) => key && value && key !== value && key.length > 1
-    )
-  );
-  try {
-    await replaceStringsInFiles(projectPath, validReplacements, {
-      verbose: true,
-      fileExtensions: [
-        ".js",
-        ".ts",
-        ".jsx",
-        ".tsx",
-        ".json",
-        "package.json",
-        ".jsonc",
-        ".md",
-        ".mdx",
-        ".html",
-        ".css",
-        ".scss",
-        ".env",
-        ".env.example",
-        "README.md"
-      ],
-      excludedDirs: [
-        "node_modules",
-        ".git",
-        "build",
-        ".next",
-        "dist",
-        "coverage",
-        ".cache",
-        ".vercel",
-        ".github"
-      ],
-      stringExclusions: [
-        "@types/",
-        /^(?:https?:\/\/)?[^\s/$.?#].[^\s]*\.[a-z]{2,}(?:\/[^\s]*)?$/i.source,
-        ...packageNames,
-        ...importPaths
-      ],
-      dryRun: false,
-      skipBinaryFiles: true,
-      maxConcurrency: 10,
-      stopOnError: false
-    });
-    if (showSuccessMessage) {
-      relinka("success", `Successfully personalized ${term} files!`);
-    }
-  } catch (error) {
-    relinka(
-      "error",
-      `\u274C Failed to personalize ${term} files:`,
-      error instanceof Error ? error.message : String(error)
-    );
-  }
-}

package/bin/impl/utils/resolve-cross-libs.d.ts

@@ -1 +0,0 @@
-export declare function resolveAllCrossLibs(strategy: "inline" | "copy" | "package" | undefined, alias: string | undefined, subFolders: ("npm" | "jsr")[] | undefined, buildPreExtensions: string[], buildTemplatesDir: string): Promise<string[]>;