@reliverse/dler 1.7.92 → 1.7.93

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

@@ -0,0 +1,216 @@
+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)) {
+        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 {
+          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/app/utils/replacements/reps-keys.d.ts

@@ -0,0 +1,19 @@
+import { type Static } from "@sinclair/typebox";
+export declare const hardcodedSchema: import("@sinclair/typebox").TObject<{
+    RelivatorTitle: import("@sinclair/typebox").TLiteral<"Relivator template is the foundation of your eCommerce platform: Build More Efficient, Engaging, and Profitable Online Stores">;
+    RelivatorShort: import("@sinclair/typebox").TLiteral<"Relivator">;
+    RelivatorLower: import("@sinclair/typebox").TLiteral<"relivator">;
+    RelivatorDomain: import("@sinclair/typebox").TLiteral<"relivator.com">;
+    DefaultAuthor: import("@sinclair/typebox").TLiteral<"blefnk">;
+    DefaultEmail: import("@sinclair/typebox").TLiteral<"onboarding@resend.dev">;
+    GeneralTemplate: import("@sinclair/typebox").TLiteral<"template">;
+}>;
+export declare const urlPatternsSchema: import("@sinclair/typebox").TObject<{
+    githubUrl: import("@sinclair/typebox").TFunction<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TString], import("@sinclair/typebox").TString>;
+    vercelUrl: import("@sinclair/typebox").TFunction<[import("@sinclair/typebox").TString], import("@sinclair/typebox").TString>;
+    packageName: import("@sinclair/typebox").TFunction<[import("@sinclair/typebox").TString], import("@sinclair/typebox").TString>;
+}>;
+export type Hardcoded = Static<typeof hardcodedSchema>;
+export type UrlPatterns = Static<typeof urlPatternsSchema>;
+export declare const HardcodedStrings: Hardcoded;
+export declare const CommonPatterns: UrlPatterns;

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

@@ -0,0 +1,31 @@
+import { Type } from "@sinclair/typebox";
+export const hardcodedSchema = Type.Object({
+  RelivatorTitle: Type.Literal(
+    "Relivator template is the foundation of your eCommerce platform: Build More Efficient, Engaging, and Profitable Online Stores"
+  ),
+  RelivatorShort: Type.Literal("Relivator"),
+  RelivatorLower: Type.Literal("relivator"),
+  RelivatorDomain: Type.Literal("relivator.com"),
+  DefaultAuthor: Type.Literal("blefnk"),
+  DefaultEmail: Type.Literal("onboarding@resend.dev"),
+  GeneralTemplate: Type.Literal("template")
+});
+export const urlPatternsSchema = Type.Object({
+  githubUrl: Type.Function([Type.String(), Type.String()], Type.String()),
+  vercelUrl: Type.Function([Type.String()], Type.String()),
+  packageName: Type.Function([Type.String()], Type.String())
+});
+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/app/utils/replacements/reps-mod.d.ts

@@ -0,0 +1,5 @@
+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/app/utils/replacements/reps-mod.js

@@ -0,0 +1,211 @@
+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)
+    );
+  }
+}