@reliverse/dler 1.7.113 → 1.7.115

package/bin/app/config/create.js

@@ -2,7 +2,6 @@ import path from "@reliverse/pathkit";
 import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
 import { confirmPrompt } from "@reliverse/rempts";
-import { Value } from "@sinclair/typebox/value";
 import { execaCommand } from "execa";
 async function addDevDependency(pkgName, opts) {
   const pkgPath = path.join(opts.cwd, "package.json");
@@ -35,12 +34,10 @@ import {
   rseName,
   UNKNOWN_VALUE
 } from "./constants.js";
-import { generateDefaultRulesForProject, getDefaultRseConfig } from "./def-utils.js";
-import { DEFAULT_CONFIG_RSE } from "./default-cfg.js";
+import { generateDefaultRulesForProject, getDefaultReliverseConfig } from "./def-utils.js";
 import { detectFeatures, getPackageJson } from "./detect.js";
-import { getRseConfigPath } from "./path.js";
-import { readRseConfig } from "./read.js";
-import { rseSchema } from "./schema.js";
+import { getReliverseConfigPath } from "./path.js";
+import { readReliverseConfig } from "./read.js";
 import {
   atomicWriteFile,
   cleanGitHubUrl,
@@ -48,7 +45,8 @@ import {
   objectToCodeString,
   updateTsConfigInclude
 } from "./utils.js";
-export async function writeRseConfig(configPath, config, isDev, skipInstallPrompt = false) {
+import { DEFAULT_CONFIG_RELIVERSE } from "../schema/mod.js";
+export async function writeReliverseConfig(configPath, config, isDev, skipInstallPrompt = false) {
   if (await fs.pathExists(configPath)) {
     relinka("verbose", `Config file already exists at ${configPath}, skipping creation`);
     return;
@@ -123,13 +121,6 @@ export default defineConfig(${objectLiteralWithComments});
       throw error;
     }
   }
-  if (!Value.Check(rseSchema, config)) {
-    const issues = [...Value.Errors(rseSchema, config)].map(
-      (err) => `Path "${err.path}": ${err.message}`
-    );
-    relinka("error", "Invalid config:", issues.join("; "));
-    throw new Error(`Invalid config: ${issues.join("; ")}`);
-  }
   let fileContent = JSON.stringify(config, null, 2);
   fileContent = injectSectionComments(fileContent);
   const { backupPath, tempPath } = getBackupAndTempPaths(configPath);
@@ -139,7 +130,7 @@ export default defineConfig(${objectLiteralWithComments});
   await atomicWriteFile(configPath, fileContent, backupPath, tempPath);
   relinka("verbose", "Config written successfully");
 }
-export async function createRseConfig(projectPath, githubUsername, isDev, overrides) {
+export async function createReliverseConfig(projectPath, githubUsername, isDev, overrides) {
   const defaultRules = await generateDefaultRulesForProject(projectPath, isDev);
   const effectiveProjectName = defaultRules?.projectName ?? path.basename(projectPath);
   let effectiveAuthorName = defaultRules?.projectAuthor ?? UNKNOWN_VALUE;
@@ -147,7 +138,7 @@ export async function createRseConfig(projectPath, githubUsername, isDev, overri
   if (effectiveAuthorName === "blefnk" && isDev) {
     effectiveAuthorName = "reliverse";
   }
-  await generateRseConfig({
+  await generateReliverseConfig({
     projectName: effectiveProjectName,
     frontendUsername: effectiveAuthorName,
     deployService: "vercel",
@@ -162,7 +153,7 @@ export async function createRseConfig(projectPath, githubUsername, isDev, overri
     defaultRules ? "Created config based on detected project settings." : "Created initial config. Please review and adjust as needed."
   );
 }
-export async function generateRseConfig({
+export async function generateReliverseConfig({
   projectName,
   frontendUsername,
   deployService,
@@ -182,7 +173,7 @@ export async function generateRseConfig({
   if (frontendUsername === "blefnk" && isDev) {
     frontendUsername = "reliverse";
   }
-  const defaultConfig = await getDefaultRseConfig(
+  const defaultConfig = await getDefaultReliverseConfig(
     projectPath,
     isDev,
     projectName,
@@ -243,18 +234,18 @@ export async function generateRseConfig({
   if (customOutputPath && customFilename) {
     effectiveConfigPath = path.join(customOutputPath, customFilename);
   } else {
-    const configPathInfo = configInfo ?? await getRseConfigPath(projectPath, isDev, skipInstallPrompt);
+    const configPathInfo = configInfo ?? await getReliverseConfigPath(projectPath, isDev, skipInstallPrompt);
     effectiveConfigPath = configPathInfo.configPath;
   }
   let existingContent = null;
   if (!overwrite && await fs.pathExists(effectiveConfigPath)) {
     try {
-      existingContent = await readRseConfig(effectiveConfigPath, isDev);
+      existingContent = await readReliverseConfig(effectiveConfigPath, isDev);
     } catch {
     }
   }
   const effectiveConfig = {
-    ...DEFAULT_CONFIG_RSE,
+    ...DEFAULT_CONFIG_RELIVERSE,
     ...existingContent,
     ...defaultConfig,
     ...overrides
@@ -262,5 +253,5 @@ export async function generateRseConfig({
   if (isDev) {
     effectiveConfig.$schema = RSE_SCHEMA_DEV;
   }
-  await writeRseConfig(effectiveConfigPath, effectiveConfig, isDev, skipInstallPrompt);
+  await writeReliverseConfig(effectiveConfigPath, effectiveConfig, isDev, skipInstallPrompt);
 }

package/bin/app/config/def-utils.d.ts

@@ -1,6 +1,6 @@
-import type { RseConfig } from "../types/mod.js";
+import type { ReliverseConfig } from "../schema/mod.js";
 /**
  * Generating a Default Config and Merging with Detected Data
  */
-export declare function getDefaultRseConfig(projectPath: string, isDev: boolean, projectName?: string, projectAuthor?: string): Promise<RseConfig>;
-export declare function generateDefaultRulesForProject(projectPath: string, isDev: boolean): Promise<RseConfig | null>;
+export declare function getDefaultReliverseConfig(projectPath: string, isDev: boolean, projectName?: string, projectAuthor?: string): Promise<ReliverseConfig>;
+export declare function generateDefaultRulesForProject(projectPath: string, isDev: boolean): Promise<ReliverseConfig | null>;

package/bin/app/config/def-utils.js

@@ -5,9 +5,9 @@ import { safeDestr } from "destr";
 import { readPackageJSON } from "pkg-types";
 import { getBiomeConfig } from "./biome.js";
 import { cliDomainDocs, DEFAULT_DOMAIN, rseName, UNKNOWN_VALUE } from "./constants.js";
-import { DEFAULT_CONFIG_RSE } from "./default-cfg.js";
 import { detectFeatures, detectProjectFramework, getPackageJsonSafe } from "./detect.js";
-export async function getDefaultRseConfig(projectPath, isDev, projectName, projectAuthor) {
+import { DEFAULT_CONFIG_RELIVERSE } from "../schema/mod.js";
+export async function getDefaultReliverseConfig(projectPath, isDev, projectName, projectAuthor) {
   const packageJson = await getPackageJsonSafe(projectPath);
   const effectiveProjectName = packageJson?.name ?? projectName ?? UNKNOWN_VALUE;
   let effectiveAuthorName = typeof packageJson?.author === "object" ? packageJson.author?.name ?? projectAuthor : packageJson?.author ?? projectAuthor ?? UNKNOWN_VALUE;
@@ -29,7 +29,7 @@ export async function getDefaultRseConfig(projectPath, isDev, projectName, proje
   }
   const detectedProjectFramework = await detectProjectFramework(projectPath);
   return {
-    ...DEFAULT_CONFIG_RSE,
+    ...DEFAULT_CONFIG_RELIVERSE,
     projectName: effectiveProjectName,
     projectAuthor: effectiveAuthorName,
     projectDescription: packageData.description ?? UNKNOWN_VALUE,
@@ -45,7 +45,7 @@ export async function getDefaultRseConfig(projectPath, isDev, projectName, proje
     projectPackageManager: detectedPkgManager.packageManager,
     projectRuntime: ["node", "deno", "bun"].includes(runtimeInfo?.name ?? "") ? runtimeInfo?.name : "node",
     codeStyle: {
-      ...DEFAULT_CONFIG_RSE.codeStyle,
+      ...DEFAULT_CONFIG_RELIVERSE.codeStyle,
       lineWidth: biomeConfig?.lineWidth ?? 80,
       indentSize: biomeConfig?.indentWidth ?? 2,
       tabWidth: biomeConfig?.indentWidth ?? 2
@@ -62,15 +62,15 @@ export async function generateDefaultRulesForProject(projectPath, isDev) {
     } catch {
     }
   }
-  const rules = await getDefaultRseConfig(projectPath, isDev);
+  const rules = await getDefaultReliverseConfig(projectPath, isDev);
   if (!projectCategory) {
     rules.features = {
-      ...DEFAULT_CONFIG_RSE.features,
+      ...DEFAULT_CONFIG_RELIVERSE.features,
       language: ["typescript"],
       themes: ["default"]
     };
     rules.preferredLibraries = {
-      ...DEFAULT_CONFIG_RSE.preferredLibraries,
+      ...DEFAULT_CONFIG_RELIVERSE.preferredLibraries,
       databaseLibrary: "drizzle",
       authentication: "better-auth"
     };
@@ -126,7 +126,9 @@ export async function generateDefaultRulesForProject(projectPath, isDev) {
   const hasValibot = "valibot" in deps;
   rules.features = await detectFeatures(projectPath, packageJson);
   if (!rules.preferredLibraries) {
-    rules.preferredLibraries = { ...DEFAULT_CONFIG_RSE.preferredLibraries };
+    rules.preferredLibraries = {
+      ...DEFAULT_CONFIG_RELIVERSE.preferredLibraries
+    };
   }
   if (hasDrizzle) {
     rules.preferredLibraries.databaseLibrary = "drizzle";

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

@@ -1,10 +1,12 @@
 import { type PackageJson } from "pkg-types";
-import type { DetectedProject, ProjectFramework } from "../types/mod.js";
+import type { ProjectFramework } from "../schema/mod.js";
+import type { DetectedProject } from "../types/mod.js";
+export declare const PROJECT_FRAMEWORK_FILES: Record<ProjectFramework, string[]>;
 export declare function detectProjectFramework(projectPath: string): Promise<ProjectFramework | null>;
 export declare function getPackageJson(projectPath: string): Promise<PackageJson | null>;
 export declare function getPackageJsonSafe(projectPath: string): Promise<PackageJson | null>;
 export declare function detectProject(projectPath: string, isDev: boolean): Promise<DetectedProject | null>;
-export declare function detectProjectsWithRseConfig(projectPath: string, isDev: boolean): Promise<DetectedProject[]>;
+export declare function detectProjectsWithReliverseConfig(projectPath: string, isDev: boolean): Promise<DetectedProject[]>;
 export declare function detectFeatures(projectPath: string, packageJson: PackageJson | null): Promise<{
     i18n: boolean;
     analytics: boolean;

package/bin/app/config/detect.js

@@ -3,9 +3,39 @@ import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
 import { readPackageJSON } from "pkg-types";
 import { getProjectContent } from "./content.js";
-import { PROJECT_FRAMEWORK_FILES } from "./default-cfg.js";
-import { getRseConfigPath } from "./path.js";
-import { readRseConfig } from "./read.js";
+import { getReliverseConfigPath } from "./path.js";
+import { readReliverseConfig } from "./read.js";
+export const PROJECT_FRAMEWORK_FILES = {
+  unknown: [],
+  nextjs: ["next.config.js", "next.config.ts", "next.config.mjs"],
+  vite: ["vite.config.js", "vite.config.ts", "react.config.js"],
+  svelte: ["svelte.config.js", "svelte.config.ts"],
+  remix: ["remix.config.js", "remix.config.ts"],
+  astro: ["astro.config.js", "astro.config.ts", "astro.config.mjs"],
+  nuxt: ["nuxt.config.js", "nuxt.config.ts"],
+  solid: ["solid.config.js", "solid.config.ts"],
+  qwik: ["qwik.config.js", "qwik.config.ts"],
+  "react-native": ["App.js", "App.tsx", "App.ts"],
+  expo: ["app.json", "app.config.js"],
+  capacitor: ["capacitor.config.ts", "capacitor.config.json"],
+  ionic: ["ionic.config.json"],
+  electron: ["electron.config.js", "electron.config.ts"],
+  tauri: ["tauri.conf.json"],
+  neutralino: ["neutralino.config.json"],
+  rempts: ["package.json:@reliverse/rempts"],
+  citty: ["package.json:citty"],
+  commander: ["package.json:commander"],
+  cac: ["package.json:cac"],
+  meow: ["package.json:meow"],
+  yargs: ["package.json:yargs"],
+  vscode: ["vscode.config.js", "vscode.config.ts"],
+  webextension: ["manifest.json"],
+  "browser-extension": ["manifest.json"],
+  "npm-jsr": ["jsr.json", "jsr.jsonc"],
+  lynx: ["App.tsx", "App.css"],
+  vue: ["vue.config.js", "vite.config.ts"],
+  wxt: ["wxt.config.js", "wxt.config.ts"]
+};
 export async function detectProjectFramework(projectPath) {
   const packageJson = await getPackageJson(projectPath);
   if (!packageJson) {
@@ -74,9 +104,9 @@ export async function detectProject(projectPath, isDev) {
   try {
     const { requiredContent, optionalContent } = await getProjectContent(projectPath);
     if (!requiredContent.filePackageJson) return null;
-    const { configPath } = await getRseConfigPath(projectPath, isDev, false);
+    const { configPath } = await getReliverseConfigPath(projectPath, isDev, false);
     if (!await fs.pathExists(configPath)) return null;
-    const config = await readRseConfig(configPath, isDev);
+    const config = await readReliverseConfig(configPath, isDev);
     if (!config) return null;
     return {
       name: path.basename(projectPath),
@@ -93,7 +123,7 @@ export async function detectProject(projectPath, isDev) {
     return null;
   }
 }
-export async function detectProjectsWithRseConfig(projectPath, isDev) {
+export async function detectProjectsWithReliverseConfig(projectPath, isDev) {
   const detected = [];
   const rootProject = await detectProject(projectPath, isDev);
   if (rootProject) detected.push(rootProject);

package/bin/app/config/gen-cfg.js

@@ -4,8 +4,8 @@ import { relinka } from "@reliverse/relinka";
 import { destr } from "destr";
 import { execaCommand } from "execa";
 import { CONFIG_CATEGORIES, UNKNOWN_VALUE } from "./constants.js";
-import { generateRseConfig } from "./create.js";
-import { getRseConfigPath } from "./path.js";
+import { generateReliverseConfig } from "./create.js";
+import { getReliverseConfigPath } from "./path.js";
 async function generateBiomeConfig(projectPath) {
   const biomePath = path.join(projectPath, "biome.json");
   const biomeExists = await fs.pathExists(biomePath);
@@ -87,11 +87,11 @@ export async function generateConfigFiles(projectPath, overwrite, projectName, d
     };
     const cleanDomain = primaryDomain.replace(/^https?:\/\//, "").replace(/\/.*$/, "");
     const finalFrontendUsername = isDev && frontendUsername === "blefnk" ? "reliverse" : frontendUsername;
-    const configInfo = await getRseConfigPath(projectPath, isDev, false);
+    const configInfo = await getReliverseConfigPath(projectPath, isDev, false);
     const mainConfigFileName = path.basename(configInfo.configPath);
     const configGenerators = {
       [mainConfigFileName]: async () => {
-        await generateRseConfig({
+        await generateReliverseConfig({
           projectName,
           frontendUsername: !finalFrontendUsername || finalFrontendUsername.trim() === "" ? UNKNOWN_VALUE : finalFrontendUsername,
           deployService,

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

@@ -1,10 +1,10 @@
-import type { DlerConfig } from "../types/mod.js";
+import type { ReliverseConfig } from "../schema/mod.js";
 /**
  * Searches for and loads the configuration file `reliverse.ts`.
  * Falls back to default configuration if the file is not found.
  * Uses jiti for seamless TypeScript and ESM support.
  */
-export declare function getConfigDler(): Promise<DlerConfig>;
+export declare function getConfigDler(): Promise<ReliverseConfig>;
 /**
  * Searches for and loads bunfig.toml configuration files.
  * Checks both local (project root) and global locations.

package/bin/app/config/load.js

@@ -2,7 +2,7 @@ import { resolve } from "@reliverse/pathkit";
 import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
 import { createJiti } from "jiti";
-import { defineConfig } from "./default.js";
+import { defineConfig } from "../schema/mod.js";
 const CONFIG_FILENAME = "reliverse.ts";
 export async function getConfigDler() {
   const cwd = process.cwd();

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

@@ -2,4 +2,4 @@
  * Migrates an external rseg file into the current project config.
  * Only migrates fields that exist in the current schema.
  */
-export declare function migrateRseConfig(externalrseth: string, projectPath: string, isDev: boolean): Promise<void>;
+export declare function migrateReliverseConfig(externalrseth: string, projectPath: string, isDev: boolean): Promise<void>;

package/bin/app/config/migrate.js

@@ -1,8 +1,8 @@
 import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
 import { parseJSONC } from "confbox";
-import { updateRseConfig } from "./update.js";
-export async function migrateRseConfig(externalrseth, projectPath, isDev) {
+import { updateReliverseConfig } from "./update.js";
+export async function migrateReliverseConfig(externalrseth, projectPath, isDev) {
   try {
     const content = await fs.readFile(externalrseth, "utf-8");
     const parsed = parseJSONC(content);
@@ -44,7 +44,11 @@ export async function migrateRseConfig(externalrseth, projectPath, isDev) {
         migratedFields.push(String(key));
       }
     }
-    const success = await updateRseConfig(projectPath, validConfig, isDev);
+    const success = await updateReliverseConfig(
+      projectPath,
+      validConfig,
+      isDev
+    );
     if (success) {
       relinka("success", "Successfully migrated config");
       relinka("verbose", "Migrated fields:", migratedFields.join(", "));

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

@@ -5,7 +5,7 @@
  * - Honors a custom tsconfig.json path if provided.
  * - Caches results by projectPath.
  */
-export declare function getRseConfigPath(projectPath: string, isDev: boolean, skipPrompt: boolean, customTsconfigPath?: string): Promise<{
+export declare function getReliverseConfigPath(projectPath: string, isDev: boolean, skipPrompt: boolean, customTsconfigPath?: string): Promise<{
     configPath: string;
     isTS: boolean;
 }>;

package/bin/app/config/path.js

@@ -1,9 +1,9 @@
 import path from "@reliverse/pathkit";
 import fs from "@reliverse/relifso";
 import { tsconfigJson } from "./constants.js";
-import { askRseConfigType } from "./prompts.js";
+import { askReliverseConfigType } from "./prompts.js";
 const configPathCache = /* @__PURE__ */ new Map();
-export async function getRseConfigPath(projectPath, isDev, skipPrompt, customTsconfigPath) {
+export async function getReliverseConfigPath(projectPath, isDev, skipPrompt, customTsconfigPath) {
   const cached = configPathCache.get(projectPath);
   if (cached) {
     return cached;
@@ -23,7 +23,7 @@ export async function getRseConfigPath(projectPath, isDev, skipPrompt, customTsc
   } else if (tsExists) {
     result = { configPath: rseTs, isTS: true };
   } else if (tsconfigExists && !jsoncExists && !skipPrompt) {
-    const choice = await askRseConfigType();
+    const choice = await askReliverseConfigType();
     result = choice === "ts" ? { configPath: rseTs, isTS: true } : { configPath: rseJsonc, isTS: false };
   } else {
     result = { configPath: rseJsonc, isTS: false };

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

@@ -1,3 +1,3 @@
 export type ConfigKind = "ts" | "jsonc";
 export declare function ensureReliverseConfig(isDev: boolean, configKind?: ConfigKind): Promise<void>;
-export declare function prepareReliverseEnvironment(isDev: boolean, configKind?: ConfigKind): Promise<void>;
+export declare function prepareReliverseEnvironment(cwd: string, isDev: boolean, configKind?: ConfigKind): Promise<void>;