@reliverse/config 1.5.11 → 2.2.7

package/dist/impl/build.d.ts

@@ -0,0 +1,166 @@
+import { type BaseConfig } from "./core.js";
+import type { PackageKind } from "./publish.js";
+export interface AssetOptions {
+    publicPath?: string;
+    copyFiles?: string[];
+    imageOptimization?: boolean;
+}
+export interface PerformanceBudget {
+    maxBundleSize?: number;
+    maxChunkSize?: number;
+    maxAssetSize?: number;
+    maxInitialChunkSize?: number;
+    maxAsyncChunkSize?: number;
+}
+export interface HtmlOptions {
+    entryPoints?: string[];
+    inject?: boolean;
+    minify?: boolean;
+}
+export interface DtsOptions {
+    /** Whether to generate declaration files */
+    enable?: boolean;
+    /** Provider for generating declaration files */
+    provider?: "dts-bundle-generator" | "api-extractor" | "typescript" | "mkdist";
+    /** Whether to bundle declaration files into a single file */
+    bundle?: boolean;
+    /** Output directory for declaration files (relative to package root) */
+    distPath?: string;
+    /** Whether to build with project references */
+    build?: boolean;
+    /** Whether to abort on declaration generation errors */
+    abortOnError?: boolean;
+    /** Whether to auto-set extension based on format (.d.ts, .d.mts, .d.cts) */
+    autoExtension?: boolean;
+    /** Path aliases for declaration files */
+    alias?: Record<string, string>;
+    /** Use experimental tsgo instead of TypeScript Compiler API */
+    tsgo?: boolean;
+    /** Banner content for declaration files */
+    banner?: string;
+    /** Footer content for declaration files */
+    footer?: string;
+    /** Options specific to dts-bundle-generator */
+    dtsBundleGenerator?: {
+        preferredConfigPath?: string;
+        externalInlines?: string[];
+        externalImports?: string[];
+        externalTypes?: string[];
+        umdModuleName?: string;
+        noBanner?: boolean;
+    };
+    /** Options specific to mkdist provider */
+    mkdist?: {
+        addRelativeDeclarationExtensions?: boolean;
+        pattern?: string;
+        globOptions?: Record<string, unknown>;
+    };
+}
+export interface GoBuildOptions {
+    /** Whether to enable Go build */
+    enable?: boolean;
+    /** Build provider: xgo (cross-compilation) or native (limited cross-compilation) */
+    provider?: "xgo" | "native";
+    /** Target platforms (e.g., "linux/amd64" or ["linux/amd64", "windows/amd64"]) */
+    targets?: string | string[];
+    /** Output directory for Go binaries (relative to package root, default: "release") */
+    outputDir?: string;
+    /** Output binary name prefix (default: derived from package name) */
+    outputName?: string;
+    /** Go build mode: c-shared, c-archive, or exe */
+    buildMode?: "c-shared" | "c-archive" | "exe";
+    /** Linker flags (default: "-s -w") */
+    ldflags?: string;
+    /** Main Go file to build (default: "main.go") */
+    mainFile?: string;
+    /** Go version for xgo (default: "1.20.3") */
+    goVersion?: string;
+}
+export interface PackageBuildConfig {
+    enable?: boolean;
+    bundler?: "bun" | "mkdist";
+    target?: "browser" | "bun" | "node";
+    format?: "esm" | "cjs" | "iife";
+    minify?: boolean | {
+        whitespace?: boolean;
+        syntax?: boolean;
+        identifiers?: boolean;
+    };
+    sourcemap?: string | boolean;
+    splitting?: boolean;
+    external?: string | string[];
+    bytecode?: boolean;
+    drop?: string | string[];
+    packages?: string;
+    publicPath?: string;
+    root?: string;
+    define?: Record<string, string>;
+    naming?: {
+        chunk?: string;
+        entry?: string;
+        asset?: string;
+    };
+    env?: string | Record<string, string>;
+    banner?: string | Record<string, string>;
+    footer?: string | Record<string, string>;
+    conditions?: string | string[];
+    loader?: Record<string, string>;
+    ignoreDCEAnnotations?: boolean;
+    emitDCEAnnotations?: boolean;
+    throw?: boolean;
+    jsx?: string | {
+        factory?: string;
+        fragment?: string;
+        importSource?: string;
+        pragma?: string;
+        pragmaFrag?: string;
+        runtime?: "automatic" | "classic";
+        development?: boolean;
+    };
+    keepNames?: boolean;
+    html?: boolean | HtmlOptions;
+    assets?: AssetOptions;
+    cssChunking?: boolean;
+    macros?: boolean;
+    sideEffects?: boolean | string[];
+    bundleAnalyzer?: boolean;
+    typeCheck?: boolean;
+    generateTypes?: boolean;
+    performanceBudget?: PerformanceBudget;
+    imageOptimization?: boolean;
+    fontOptimization?: boolean;
+    cssOptimization?: boolean;
+    svgAsReact?: boolean;
+    cssModules?: boolean;
+    workerSupport?: boolean;
+    compile?: boolean;
+    windowsHideConsole?: boolean;
+    windowsIcon?: string;
+    windowsTitle?: string;
+    windowsPublisher?: string;
+    windowsVersion?: string;
+    windowsDescription?: string;
+    windowsCopyright?: string;
+    dts?: boolean | DtsOptions;
+    go?: GoBuildOptions;
+    kind?: PackageKind;
+    bin?: string;
+}
+export interface BuildConfig extends BaseConfig {
+    global?: PackageBuildConfig;
+    packages?: Record<string, PackageBuildConfig>;
+    patterns?: Array<{
+        pattern: string;
+        config: PackageBuildConfig;
+    }>;
+}
+/**
+ * Get package-specific build configuration from dler.ts
+ */
+export declare const getPackageBuildConfig: (packageName: string, dlerConfig: {
+    build?: BuildConfig;
+} | null) => Promise<PackageBuildConfig | undefined>;
+/**
+ * Merge build options with package-specific configuration
+ */
+export declare const mergeBuildOptions: <T extends Record<string, any>>(cliOptions: T, packageConfig?: PackageBuildConfig) => T;

package/dist/impl/build.js

@@ -0,0 +1,10 @@
+import { mergeConfig, resolvePackageConfig } from "./core.js";
+export const getPackageBuildConfig = async (packageName, dlerConfig) => {
+  return resolvePackageConfig(
+    packageName,
+    dlerConfig?.build
+  );
+};
+export const mergeBuildOptions = (cliOptions, packageConfig) => {
+  return mergeConfig(cliOptions, packageConfig);
+};

package/dist/impl/core.d.ts

@@ -0,0 +1,24 @@
+import type { BuildConfig } from "./build.js";
+import type { PublishConfig } from "./publish.js";
+export interface BaseConfig {
+    global?: Record<string, any>;
+    packages?: Record<string, Record<string, any>>;
+    patterns?: Array<{
+        pattern: string;
+        config: Record<string, any>;
+    }>;
+}
+export interface DlerConfig {
+    build?: BuildConfig;
+    publish?: PublishConfig;
+}
+/**
+ * Generic function to resolve package-specific configuration using pattern matching
+ * Priority: packages (exact match) → patterns (glob match) → global
+ */
+export declare const resolvePackageConfig: <T extends Record<string, any>>(packageName: string, config: BaseConfig | null | undefined) => T | undefined;
+/**
+ * Generic function to merge configuration options
+ * CLI options take precedence over config options
+ */
+export declare const mergeConfig: <T extends Record<string, any>>(cliOptions: T, configOptions?: Record<string, any>) => T;

package/dist/impl/core.js

@@ -0,0 +1,36 @@
+export const resolvePackageConfig = (packageName, config) => {
+  if (!config) {
+    return;
+  }
+  if (config.packages?.[packageName]) {
+    const packageConfig = config.packages[packageName];
+    if (packageConfig.enable === false) {
+      return;
+    }
+    return packageConfig;
+  }
+  if (config.patterns) {
+    for (const { pattern, config: patternConfig } of config.patterns) {
+      const regexPattern = pattern.replace(/\*/g, ".*");
+      const patternWithoutWildcards = pattern.replace(/\*/g, "");
+      if (patternWithoutWildcards && packageName.includes(patternWithoutWildcards) || new RegExp(regexPattern).test(packageName)) {
+        if (patternConfig.enable === false) {
+          return;
+        }
+        return patternConfig;
+      }
+    }
+  }
+  const globalConfig = config.global;
+  if (globalConfig?.enable === false) {
+    return;
+  }
+  return globalConfig;
+};
+export const mergeConfig = (cliOptions, configOptions) => {
+  if (!configOptions) return cliOptions;
+  return {
+    ...configOptions,
+    ...cliOptions
+  };
+};

package/dist/impl/discovery.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Find monorepo root by looking for package.json with workspaces field
+ */
+export declare const findMonorepoRoot: (cwd?: string) => Promise<string | null>;
+/**
+ * Get workspace patterns from package.json
+ */
+export declare const getWorkspacePatterns: (pkg: any) => string[];
+/**
+ * Check if package has workspaces
+ */
+export declare const hasWorkspaces: (pkg: any) => boolean;
+/**
+ * Resolve package info for a given path
+ */
+export declare const resolvePackageInfo: (packagePath: string) => Promise<{
+    name: string;
+    path: string;
+    pkg: any;
+} | null>;
+/**
+ * Get all workspace packages
+ */
+export declare const getWorkspacePackages: (cwd?: string) => Promise<{
+    name: string;
+    path: string;
+    pkg: any;
+}[]>;
+/**
+ * Filter packages based on ignore patterns or include filter
+ */
+export declare const filterPackages: (packages: {
+    name: string;
+    path: string;
+    pkg: any;
+}[], ignore?: string | string[], filter?: string | string[]) => {
+    name: string;
+    path: string;
+    pkg: any;
+}[];
+/**
+ * Load dler.ts configuration using c12
+ *
+ * c12 automatically handles:
+ * - Searching up directory tree for config files
+ * - Loading TypeScript/JavaScript config files
+ * - Merging multiple config sources (dler.ts, package.json, .dlerrc, etc.)
+ * - Environment-specific configurations ($test, $development, $production)
+ * - Config extending from remote/local sources
+ *
+ * Additional c12 features available:
+ * - .config/ directory support
+ * - RC file support (.dlerrc)
+ * - Environment-specific configs ($env: { staging: {...} })
+ * - Config watching with auto-reload
+ * - Remote config extending (gh:user/repo)
+ */
+export declare const loadDlerConfig: <T extends Record<string, any> = any>(cwd?: string) => Promise<T | null>;
+/**
+ * Watch dler.ts configuration for changes (development mode)
+ * Uses c12's watchConfig for auto-reload and HMR support
+ */
+export declare const watchDlerConfig: <T extends Record<string, any> = any>(cwd?: string, options?: {
+    onUpdate?: (config: T) => void;
+    onError?: (error: Error) => void;
+}) => Promise<import("c12").ConfigWatcher<T, import("c12").ConfigLayerMeta>>;

package/dist/impl/discovery.js

@@ -0,0 +1,158 @@
+import { dirname, resolve } from "node:path";
+import { createIncludeFilter } from "@reliverse/matcha";
+import { readPackageJSON } from "@reliverse/typerso";
+import { loadConfig, watchConfig } from "c12";
+export const findMonorepoRoot = async (cwd) => {
+  let currentDir = cwd || process.cwd();
+  const maxDepth = 10;
+  let depth = 0;
+  while (depth < maxDepth) {
+    try {
+      const pkg = await readPackageJSON(currentDir);
+      if (pkg?.workspaces) {
+        return currentDir;
+      }
+    } catch {
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+    depth++;
+  }
+  return null;
+};
+export const getWorkspacePatterns = (pkg) => {
+  if (!pkg.workspaces) return [];
+  if (Array.isArray(pkg.workspaces)) {
+    return pkg.workspaces;
+  }
+  if (pkg.workspaces.packages) {
+    return pkg.workspaces.packages;
+  }
+  return [];
+};
+export const hasWorkspaces = (pkg) => {
+  return !!(pkg.workspaces && (Array.isArray(pkg.workspaces) || typeof pkg.workspaces === "object" && pkg.workspaces.packages));
+};
+export const resolvePackageInfo = async (packagePath) => {
+  try {
+    const pkg = await readPackageJSON(packagePath);
+    if (!pkg || !pkg.name) {
+      return null;
+    }
+    return {
+      name: pkg.name,
+      path: packagePath,
+      pkg
+    };
+  } catch {
+    return null;
+  }
+};
+export const getWorkspacePackages = async (cwd) => {
+  const monorepoRoot = await findMonorepoRoot(cwd);
+  if (!monorepoRoot) {
+    const currentDir = cwd || process.cwd();
+    const currentPkg = await readPackageJSON(currentDir);
+    if (currentPkg?.name) {
+      return [
+        {
+          name: currentPkg.name,
+          path: currentDir,
+          pkg: currentPkg
+        }
+      ];
+    }
+    throw new Error(
+      "\u274C No monorepo or valid package found. Ensure package.json has 'workspaces' field or contains a valid 'name' field."
+    );
+  }
+  const rootPkg = await readPackageJSON(monorepoRoot);
+  if (!rootPkg) {
+    throw new Error("\u274C Could not read root package.json");
+  }
+  const patterns = getWorkspacePatterns(rootPkg);
+  if (!patterns.length) {
+    throw new Error("\u274C No workspace patterns found in package.json");
+  }
+  const packages = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    if (pattern.includes("*")) {
+      const glob = new Bun.Glob(pattern);
+      const matches = glob.scanSync({ cwd: monorepoRoot, onlyFiles: false });
+      for (const match of matches) {
+        const packagePath = resolve(monorepoRoot, match);
+        if (seenPaths.has(packagePath)) continue;
+        seenPaths.add(packagePath);
+        const pkgInfo = await resolvePackageInfo(packagePath);
+        if (pkgInfo) {
+          packages.push(pkgInfo);
+        }
+      }
+    } else {
+      const packagePath = resolve(monorepoRoot, pattern);
+      if (seenPaths.has(packagePath)) continue;
+      seenPaths.add(packagePath);
+      const pkgInfo = await resolvePackageInfo(packagePath);
+      if (pkgInfo) {
+        packages.push(pkgInfo);
+      }
+    }
+  }
+  const filteredPackages = packages.filter((pkg) => {
+    const normalizedPkgPath = resolve(pkg.path);
+    const normalizedRootPath = resolve(monorepoRoot);
+    return normalizedPkgPath !== normalizedRootPath;
+  });
+  return filteredPackages;
+};
+export const filterPackages = (packages, ignore, filter) => {
+  if (filter) {
+    const includeFilter = createIncludeFilter(filter);
+    return includeFilter(packages);
+  }
+  if (!ignore) return packages;
+  const ignorePatterns = Array.isArray(ignore) ? ignore : [ignore];
+  return packages.filter((pkg) => {
+    return !ignorePatterns.some((pattern) => {
+      if (pattern.includes("*")) {
+        const regex = new RegExp(pattern.replace(/\*/g, ".*"));
+        return regex.test(pkg.name);
+      }
+      return pkg.name === pattern;
+    });
+  });
+};
+export const loadDlerConfig = async (cwd) => {
+  try {
+    const { config } = await loadConfig({
+      cwd: cwd || process.cwd(),
+      name: "dler",
+      configFile: "dler",
+      packageJson: "dler",
+      // Enable reading from package.json "dler" field
+      dotenv: false
+    });
+    return config || null;
+  } catch (_error) {
+    return null;
+  }
+};
+export const watchDlerConfig = (cwd, options) => {
+  return watchConfig({
+    cwd: cwd || process.cwd(),
+    name: "dler",
+    configFile: "dler",
+    packageJson: "dler",
+    dotenv: false,
+    onUpdate: ({ newConfig }) => {
+      options?.onUpdate?.(newConfig.config);
+    },
+    onWatch: (event) => {
+      console.log("[dler config watcher]", event.type, event.path);
+    }
+  });
+};

package/dist/impl/publish.d.ts

@@ -0,0 +1,39 @@
+import { type BaseConfig } from "./core.js";
+import type { BumpType } from "./types.js";
+export type RegistryType = "npm" | "jsr" | "vercel" | "npm-jsr" | "none";
+export type PackageKind = "library" | "browser-app" | "native-app" | "cli";
+export interface PackagePublishConfig {
+    enable?: boolean;
+    dryRun?: boolean;
+    tag?: string;
+    access?: "public" | "restricted";
+    otp?: string;
+    authType?: "web" | "legacy";
+    concurrency?: number;
+    verbose?: boolean;
+    bump?: BumpType;
+    bumpDisable?: boolean;
+    registry?: RegistryType;
+    kind?: PackageKind;
+    bin?: string;
+}
+export interface PublishConfig extends BaseConfig {
+    global?: PackagePublishConfig;
+    packages?: Record<string, PackagePublishConfig>;
+    patterns?: Array<{
+        pattern: string;
+        config: PackagePublishConfig;
+    }>;
+}
+/**
+ * Get package-specific publish configuration from dler.ts
+ */
+export declare const getPackagePublishConfig: (packageName: string, dlerConfig: {
+    publish?: PublishConfig;
+} | null) => PackagePublishConfig | undefined;
+/**
+ * Merge CLI options with dler.ts configuration
+ */
+export declare const mergePublishOptions: <T extends Record<string, any>>(cliOptions: T, packageName: string, dlerConfig: {
+    publish?: PublishConfig;
+} | null) => T;

package/dist/impl/publish.js

@@ -0,0 +1,11 @@
+import { mergeConfig, resolvePackageConfig } from "./core.js";
+export const getPackagePublishConfig = (packageName, dlerConfig) => {
+  return resolvePackageConfig(
+    packageName,
+    dlerConfig?.publish
+  );
+};
+export const mergePublishOptions = (cliOptions, packageName, dlerConfig) => {
+  const packageConfig = getPackagePublishConfig(packageName, dlerConfig);
+  return mergeConfig(cliOptions, packageConfig);
+};

package/dist/impl/types.d.ts

@@ -0,0 +1,7 @@
+import type { ReleaseType } from "semver";
+export type BumpType = ReleaseType | "prerelease";
+export interface VersionInfo {
+    current: string;
+    bumped: string;
+    type: BumpType;
+}

package/dist/mod.d.ts

@@ -0,0 +1,21 @@
+import type { BumpType, VersionInfo } from "./impl/types.js";
+/**
+ * Parse and validate a semver version string
+ */
+export declare function parseVersion(version: string): string | null;
+/**
+ * Bump a version string according to the specified type
+ */
+export declare function bumpVersion(currentVersion: string, type: BumpType): VersionInfo | null;
+/**
+ * Get the next version for a given type without bumping
+ */
+export declare function getNextVersion(currentVersion: string, type: BumpType): string | null;
+/**
+ * Check if a version is a prerelease
+ */
+export declare function isPrerelease(version: string): boolean;
+/**
+ * Get the release type of a version (major, minor, patch)
+ */
+export declare function getReleaseType(version: string): "major" | "minor" | "patch" | null;

package/dist/mod.js

@@ -0,0 +1,45 @@
+import { inc, parse, valid } from "semver";
+export function parseVersion(version) {
+  if (!valid(version)) {
+    return null;
+  }
+  return version;
+}
+export function bumpVersion(currentVersion, type) {
+  const parsed = parse(currentVersion);
+  if (!parsed) {
+    return null;
+  }
+  const bumped = inc(parsed, type);
+  if (!bumped) {
+    return null;
+  }
+  return {
+    current: currentVersion,
+    bumped,
+    type
+  };
+}
+export function getNextVersion(currentVersion, type) {
+  const parsed = parse(currentVersion);
+  if (!parsed) {
+    return null;
+  }
+  return inc(parsed, type) || null;
+}
+export function isPrerelease(version) {
+  if (!version.includes("-")) {
+    return false;
+  }
+  const parsed = parse(version);
+  return parsed ? parsed.prerelease.length > 0 : false;
+}
+export function getReleaseType(version) {
+  const parsed = parse(version);
+  if (!parsed) {
+    return null;
+  }
+  if (parsed.major > 0) return "major";
+  if (parsed.minor > 0) return "minor";
+  return "patch";
+}

package/package.json

@@ -1,43 +1,38 @@
 {
   "name": "@reliverse/config",
-  "version": "1.5.11",
-  "license": "MIT",
-  "description": "This CLI tool can help you easily create new web projects, manage existing projects, and automatically make advanced codebase modifications, with more features coming soon.",
-  "type": "module",
+  "description": "Configuration management for Reliverse ecosystem",
   "author": "reliverse",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/reliverse/cli.git"
-  },
-  "bugs": {
-    "url": "https://github.com/reliverse/cli/issues",
-    "email": "blefnk@gmail.com"
-  },
-  "keywords": [
-    "cli",
-    "reliverse"
-  ],
-  "main": "./bin/main.js",
-  "module": "./bin/main.js",
+  "version": "2.2.7",
+  "private": false,
+  "type": "module",
   "exports": {
-    ".": "./bin/main.js"
+    ".": {
+      "types": "./dist/mod.d.ts",
+      "default": "./dist/mod.js"
+    },
+    "./impl/*": {
+      "types": "./dist/impl/*.d.ts",
+      "default": "./dist/impl/*.js"
+    }
   },
-  "bin": {
-    "config": "bin/main.js"
+  "dependencies": {
+    "c12": "^3.3.3",
+    "semver": "^7.7.3",
+    "@reliverse/matcha": "2.2.7",
+    "@reliverse/typerso": "2.2.7"
   },
-  "files": [
-    "bin",
-    "package.json",
-    "README.md",
-    "LICENSE"
+  "keywords": [
+    "dler",
+    "config",
+    "build",
+    "publish"
   ],
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "@sinclair/typebox": "^0.34.28",
-    "fs-extra": "^11.3.0",
-    "pathe": "^2.0.3"
-  },
-  "devDependencies": {}
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "license": "MIT"
 }

package/LICENSE

@@ -1,21 +0,0 @@
-# MIT License
-
-Copyright (c) 2025 Nazarii Korniienko
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.