@reliverse/dler 2.2.5 → 2.2.10

package/dist/cmds/perf/reporters/json.d.ts

@@ -1,9 +0,0 @@
-import type { PerfReport } from "../types.js";
-export declare class JsonReporter {
-    private outputPath?;
-    constructor(outputPath?: string);
-    report(report: PerfReport): void;
-    static save(report: PerfReport, outputPath: string): void;
-    static print(report: PerfReport): void;
-}
-export declare const createJsonReporter: (outputPath?: string) => JsonReporter;

package/dist/cmds/perf/reporters/json.js

@@ -1,32 +0,0 @@
-import { writeFileSync } from "node:fs";
-import { logger } from "@reliverse/dler-logger";
-export class JsonReporter {
-  outputPath;
-  constructor(outputPath) {
-    this.outputPath = outputPath;
-  }
-  report(report) {
-    const json = JSON.stringify(report, null, 2);
-    if (this.outputPath) {
-      try {
-        writeFileSync(this.outputPath, json, "utf-8");
-        logger.success(`\u{1F4C4} JSON report saved to: ${this.outputPath}`);
-      } catch (error) {
-        logger.error(`Failed to save JSON report: ${error}`);
-      }
-    } else {
-      console.log(json);
-    }
-  }
-  static save(report, outputPath) {
-    const reporter = new JsonReporter(outputPath);
-    reporter.report(report);
-  }
-  static print(report) {
-    const reporter = new JsonReporter();
-    reporter.report(report);
-  }
-}
-export const createJsonReporter = (outputPath) => {
-  return new JsonReporter(outputPath);
-};

package/dist/cmds/perf/types.d.ts

@@ -1,184 +0,0 @@
-export interface PerfOptions {
-    target?: string;
-    type?: string;
-    runs?: number;
-    warmup?: number;
-    concurrency?: number;
-    compare?: boolean;
-    output?: string;
-    save?: boolean;
-    verbose?: boolean;
-    cwd?: string;
-    ignore?: string | string[];
-}
-export type PerfAnalysisType = "command" | "bundle" | "file" | "monorepo" | "auto";
-export type PerfOutputFormat = "console" | "json" | "html" | "all";
-export interface BenchmarkResult {
-    command: string;
-    runs: number;
-    warmup: number;
-    concurrency: number;
-    measurements: Measurement[];
-    statistics: Statistics;
-    memory: MemoryStats;
-    executionTime: number;
-    success: boolean;
-    error?: string;
-}
-export interface Measurement {
-    run: number;
-    duration: number;
-    memory: MemoryUsage;
-    success: boolean;
-    error?: string;
-    stdout?: string;
-    stderr?: string;
-}
-export interface Statistics {
-    min: number;
-    max: number;
-    mean: number;
-    median: number;
-    p95: number;
-    p99: number;
-    variance: number;
-    standardDeviation: number;
-    coefficientOfVariation: number;
-}
-export interface MemoryUsage {
-    rss: number;
-    heapTotal: number;
-    heapUsed: number;
-    external: number;
-    arrayBuffers: number;
-}
-export interface MemoryStats {
-    peak: MemoryUsage;
-    average: MemoryUsage;
-    growth: number;
-}
-export interface BundleAnalysisResult {
-    target: string;
-    totalSize: number;
-    fileCount: number;
-    largestFiles: FileSize[];
-    modules: ModuleInfo[];
-    duplicates: DuplicateInfo[];
-    compressionPotential: number;
-    analysisTime: number;
-}
-export interface FileSize {
-    path: string;
-    size: number;
-    percentage: number;
-    type: string;
-}
-export interface ModuleInfo {
-    name: string;
-    size: number;
-    percentage: number;
-    dependencies: string[];
-    isExternal: boolean;
-}
-export interface DuplicateInfo {
-    name: string;
-    count: number;
-    totalSize: number;
-    locations: string[];
-}
-export interface FileSystemAnalysisResult {
-    target: string;
-    totalFiles: number;
-    totalSize: number;
-    directoryCount: number;
-    maxDepth: number;
-    largestFiles: FileSize[];
-    largestDirectories: DirectorySize[];
-    fileTypes: FileTypeDistribution[];
-    compressionPotential: number;
-    analysisTime: number;
-}
-export interface DirectorySize {
-    path: string;
-    size: number;
-    fileCount: number;
-    depth: number;
-}
-export interface FileTypeDistribution {
-    extension: string;
-    count: number;
-    totalSize: number;
-    percentage: number;
-}
-export interface MonorepoAnalysisResult {
-    packages: PackageInfo[];
-    dependencies: DependencyGraph;
-    circularDependencies: CircularDependency[];
-    criticalPath: string[];
-    buildOrder: string[];
-    bottlenecks: Bottleneck[];
-    suggestedConcurrency: number;
-    analysisTime: number;
-}
-export interface PackageInfo {
-    name: string;
-    path: string;
-    dependencies: string[];
-    dependents: string[];
-    buildTime?: number;
-    size?: number;
-}
-export interface DependencyGraph {
-    nodes: string[];
-    edges: DependencyEdge[];
-    levels: string[][];
-}
-export interface DependencyEdge {
-    from: string;
-    to: string;
-    type: "dependency" | "devDependency" | "peerDependency";
-}
-export interface CircularDependency {
-    packages: string[];
-    cycle: string[];
-    severity: "low" | "medium" | "high";
-}
-export interface Bottleneck {
-    package: string;
-    type: "slow-build" | "many-dependencies" | "circular-dependency";
-    impact: number;
-    suggestion: string;
-}
-export interface PerfReport {
-    timestamp: number;
-    options: PerfOptions;
-    benchmark?: BenchmarkResult;
-    bundleAnalysis?: BundleAnalysisResult;
-    fileSystemAnalysis?: FileSystemAnalysisResult;
-    monorepoAnalysis?: MonorepoAnalysisResult;
-    baseline?: BaselineComparison;
-}
-export interface BaselineComparison {
-    exists: boolean;
-    improvement?: number;
-    regression?: number;
-    changes?: ChangeSummary;
-}
-export interface ChangeSummary {
-    duration?: number;
-    memory?: number;
-    size?: number;
-    files?: number;
-}
-export interface CacheEntry {
-    timestamp: number;
-    report: PerfReport;
-    hash: string;
-}
-export interface CacheOptions {
-    enabled: boolean;
-    cacheDir: string;
-    maxAge: number;
-}
-export type AnalysisResult = BundleAnalysisResult | FileSystemAnalysisResult | MonorepoAnalysisResult;
-export type OutputFormat = PerfOutputFormat;

package/dist/cmds/perf/utils/cache.d.ts

@@ -1,23 +0,0 @@
-import type { CacheOptions, PerfReport } from "../types.js";
-export declare class PerfCache {
-    private options;
-    private cacheDir;
-    constructor(options: CacheOptions);
-    ensureCacheDir(): void;
-    private generateHash;
-    private getCachePath;
-    private isExpired;
-    save(report: PerfReport): Promise<void>;
-    load(target: string, type?: string): Promise<PerfReport | null>;
-    findBaseline(target: string, type?: string): Promise<PerfReport | null>;
-    listBaselines(): Promise<Array<{
-        target: string;
-        type?: string;
-        timestamp: number;
-        hash: string;
-    }>>;
-    clear(): Promise<void>;
-    cleanup(): Promise<void>;
-    getCacheSize(): number;
-}
-export declare const createPerfCache: (options?: Partial<CacheOptions>) => PerfCache;

package/dist/cmds/perf/utils/cache.js

@@ -1,172 +0,0 @@
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-export class PerfCache {
-  options;
-  cacheDir;
-  constructor(options) {
-    this.options = options;
-    this.cacheDir = resolve(options.cacheDir);
-    this.ensureCacheDir();
-  }
-  ensureCacheDir() {
-    if (existsSync(this.cacheDir)) {
-      return;
-    }
-    mkdirSync(this.cacheDir, { recursive: true });
-  }
-  generateHash(report) {
-    const content = JSON.stringify({
-      target: report.options.target,
-      type: report.options.type,
-      // Exclude timestamp and other volatile fields
-      benchmark: report.benchmark ? {
-        command: report.benchmark.command,
-        runs: report.benchmark.runs,
-        concurrency: report.benchmark.concurrency
-      } : void 0
-    });
-    return createHash("sha256").update(content).digest("hex").substring(0, 16);
-  }
-  getCachePath(hash) {
-    return join(this.cacheDir, `${hash}.json`);
-  }
-  isExpired(entry) {
-    if (!this.options.enabled) return true;
-    const age = Date.now() - entry.timestamp;
-    return age > this.options.maxAge;
-  }
-  async save(report) {
-    if (!this.options.enabled) return;
-    try {
-      const hash = this.generateHash(report);
-      const entry = {
-        timestamp: Date.now(),
-        report,
-        hash
-      };
-      const cachePath = this.getCachePath(hash);
-      writeFileSync(cachePath, JSON.stringify(entry, null, 2));
-    } catch (error) {
-      console.warn("Failed to save performance cache:", error);
-    }
-  }
-  async load(target, type) {
-    if (!this.options.enabled) return null;
-    try {
-      const cacheFiles = Array.from(
-        new Bun.Glob("*.json").scanSync({ cwd: this.cacheDir })
-      );
-      for (const file of cacheFiles) {
-        const cachePath = join(this.cacheDir, file);
-        try {
-          const content = readFileSync(cachePath, "utf-8");
-          const entry = JSON.parse(content);
-          if (this.isExpired(entry)) {
-            continue;
-          }
-          if (entry.report.options.target === target && (!type || entry.report.options.type === type)) {
-            return entry.report;
-          }
-        } catch {
-          continue;
-        }
-      }
-      return null;
-    } catch (error) {
-      console.warn("Failed to load performance cache:", error);
-      return null;
-    }
-  }
-  async findBaseline(target, type) {
-    return this.load(target, type);
-  }
-  async listBaselines() {
-    if (!this.options.enabled) return [];
-    try {
-      const cacheFiles = Array.from(
-        new Bun.Glob("*.json").scanSync({ cwd: this.cacheDir })
-      );
-      const baselines = [];
-      for (const file of cacheFiles) {
-        const cachePath = join(this.cacheDir, file);
-        try {
-          const content = readFileSync(cachePath, "utf-8");
-          const entry = JSON.parse(content);
-          if (!this.isExpired(entry)) {
-            baselines.push({
-              target: entry.report.options.target ?? "unknown",
-              type: entry.report.options.type,
-              timestamp: entry.timestamp,
-              hash: entry.hash
-            });
-          }
-        } catch {
-          continue;
-        }
-      }
-      return baselines.sort((a, b) => b.timestamp - a.timestamp);
-    } catch (error) {
-      console.warn("Failed to list performance baselines:", error);
-      return [];
-    }
-  }
-  async clear() {
-    if (!this.options.enabled) return;
-    try {
-      const cacheFiles = Array.from(
-        new Bun.Glob("*.json").scanSync({ cwd: this.cacheDir })
-      );
-      for (const file of cacheFiles) {
-        const cachePath = join(this.cacheDir, file);
-        try {
-          Bun.write(cachePath, "");
-        } catch {
-        }
-      }
-    } catch (error) {
-      console.warn("Failed to clear performance cache:", error);
-    }
-  }
-  async cleanup() {
-    if (!this.options.enabled) return;
-    try {
-      const cacheFiles = Array.from(
-        new Bun.Glob("*.json").scanSync({ cwd: this.cacheDir })
-      );
-      for (const file of cacheFiles) {
-        const cachePath = join(this.cacheDir, file);
-        try {
-          const content = readFileSync(cachePath, "utf-8");
-          const entry = JSON.parse(content);
-          if (this.isExpired(entry)) {
-            Bun.write(cachePath, "");
-          }
-        } catch {
-          continue;
-        }
-      }
-    } catch (error) {
-      console.warn("Failed to cleanup performance cache:", error);
-    }
-  }
-  getCacheSize() {
-    try {
-      const cacheFiles = Array.from(
-        new Bun.Glob("*.json").scanSync({ cwd: this.cacheDir })
-      );
-      return cacheFiles.length;
-    } catch {
-      return 0;
-    }
-  }
-}
-export const createPerfCache = (options = {}) => {
-  const defaultOptions = {
-    enabled: true,
-    cacheDir: ".dler-cache/perf",
-    maxAge: 7 * 24 * 60 * 60 * 1e3
-    // 7 days
-  };
-  return new PerfCache({ ...defaultOptions, ...options });
-};

package/dist/cmds/perf/utils/formatter.d.ts

@@ -1,17 +0,0 @@
-export declare const formatDuration: (ms: number) => string;
-export declare const formatBytes: (bytes: number) => string;
-export declare const formatPercentage: (value: number, total: number) => string;
-export declare const formatNumber: (num: number) => string;
-export declare const formatMemory: (bytes: number) => string;
-export declare const formatImprovement: (improvement: number) => string;
-export declare const formatRegression: (regression: number) => string;
-export declare const formatConfidenceInterval: (lower: number, upper: number, formatter?: (ms: number) => string) => string;
-export declare const formatProgress: (current: number, total: number) => string;
-export declare const formatTable: (headers: string[], rows: string[][]) => string;
-export declare const formatDurationBar: (value: number, max: number, width?: number) => string;
-export declare const formatSizeBar: (value: number, max: number, width?: number) => string;
-export declare const formatRelativeChange: (baseline: number, current: number) => string;
-export declare const truncatePath: (path: string, maxLength?: number) => string;
-export declare const formatFileType: (extension: string) => string;
-export declare const formatSeverity: (severity: "low" | "medium" | "high") => string;
-export declare const formatBottleneckType: (type: "slow-build" | "many-dependencies" | "circular-dependency") => string;

package/dist/cmds/perf/utils/formatter.js

@@ -1,134 +0,0 @@
-export const formatDuration = (ms) => {
-  if (ms < 1e3) {
-    return `${ms.toFixed(2)}ms`;
-  }
-  if (ms < 6e4) {
-    return `${(ms / 1e3).toFixed(2)}s`;
-  }
-  const minutes = Math.floor(ms / 6e4);
-  const seconds = (ms % 6e4 / 1e3).toFixed(2);
-  return `${minutes}m ${seconds}s`;
-};
-export const formatBytes = (bytes) => {
-  if (bytes === 0) return "0 B";
-  const k = 1024;
-  const sizes = ["B", "KB", "MB", "GB", "TB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
-};
-export const formatPercentage = (value, total) => {
-  if (total === 0) return "0.00%";
-  return `${(value / total * 100).toFixed(2)}%`;
-};
-export const formatNumber = (num) => {
-  if (num < 1e3) return num.toString();
-  if (num < 1e6) return `${(num / 1e3).toFixed(1)}K`;
-  if (num < 1e9) return `${(num / 1e6).toFixed(1)}M`;
-  return `${(num / 1e9).toFixed(1)}B`;
-};
-export const formatMemory = (bytes) => {
-  return formatBytes(bytes);
-};
-export const formatImprovement = (improvement) => {
-  const sign = improvement > 0 ? "+" : "";
-  return `${sign}${improvement.toFixed(2)}%`;
-};
-export const formatRegression = (regression) => {
-  return `+${regression.toFixed(2)}%`;
-};
-export const formatConfidenceInterval = (lower, upper, formatter = formatDuration) => {
-  return `${formatter(lower)} - ${formatter(upper)}`;
-};
-export const formatProgress = (current, total) => {
-  const percentage = total === 0 ? 0 : current / total * 100;
-  const barLength = 20;
-  const filled = Math.floor(percentage / 100 * barLength);
-  const bar = "\u2588".repeat(filled) + "\u2591".repeat(barLength - filled);
-  return `[${bar}] ${percentage.toFixed(1)}% (${current}/${total})`;
-};
-export const formatTable = (headers, rows) => {
-  if (rows.length === 0) return "";
-  const widths = headers.map((header, i) => {
-    const maxRowWidth = Math.max(...rows.map((row) => row[i]?.length ?? 0));
-    return Math.max(header.length, maxRowWidth);
-  });
-  const separator = "\u2500".repeat(widths.reduce((sum, w) => sum + w + 3, 0) - 1);
-  const headerRow = headers.map((header, i) => header.padEnd(widths[i])).join(" \u2502 ");
-  const dataRows = rows.map(
-    (row) => row.map((cell, i) => (cell ?? "").padEnd(widths[i])).join(" \u2502 ")
-  );
-  return [headerRow, separator, ...dataRows].join("\n");
-};
-export const formatDurationBar = (value, max, width = 20) => {
-  const percentage = max === 0 ? 0 : value / max * 100;
-  const filled = Math.floor(percentage / 100 * width);
-  const bar = "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
-  return `${bar} ${formatDuration(value)}`;
-};
-export const formatSizeBar = (value, max, width = 20) => {
-  const percentage = max === 0 ? 0 : value / max * 100;
-  const filled = Math.floor(percentage / 100 * width);
-  const bar = "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
-  return `${bar} ${formatBytes(value)}`;
-};
-export const formatRelativeChange = (baseline, current) => {
-  if (baseline === 0) return "N/A";
-  const change = (current - baseline) / baseline * 100;
-  const sign = change > 0 ? "+" : "";
-  const color = change > 0 ? "\u{1F534}" : change < 0 ? "\u{1F7E2}" : "\u26AA";
-  return `${color} ${sign}${change.toFixed(2)}%`;
-};
-export const truncatePath = (path, maxLength = 50) => {
-  if (path.length <= maxLength) return path;
-  const start = path.substring(0, Math.floor(maxLength / 2) - 2);
-  const end = path.substring(path.length - Math.floor(maxLength / 2) + 2);
-  return `${start}...${end}`;
-};
-export const formatFileType = (extension) => {
-  const typeMap = {
-    ".js": "JavaScript",
-    ".ts": "TypeScript",
-    ".jsx": "React JSX",
-    ".tsx": "React TSX",
-    ".json": "JSON",
-    ".css": "CSS",
-    ".scss": "SCSS",
-    ".sass": "Sass",
-    ".less": "Less",
-    ".html": "HTML",
-    ".svg": "SVG",
-    ".png": "PNG",
-    ".jpg": "JPEG",
-    ".jpeg": "JPEG",
-    ".gif": "GIF",
-    ".webp": "WebP",
-    ".woff": "WOFF",
-    ".woff2": "WOFF2",
-    ".ttf": "TrueType",
-    ".eot": "EOT",
-    ".map": "Source Map",
-    ".d.ts": "TypeScript Declarations"
-  };
-  return typeMap[extension] ?? extension.toUpperCase();
-};
-export const formatSeverity = (severity) => {
-  const icons = {
-    low: "\u{1F7E1}",
-    medium: "\u{1F7E0}",
-    high: "\u{1F534}"
-  };
-  return `${icons[severity]} ${severity.toUpperCase()}`;
-};
-export const formatBottleneckType = (type) => {
-  const icons = {
-    "slow-build": "\u23F1\uFE0F",
-    "many-dependencies": "\u{1F517}",
-    "circular-dependency": "\u{1F504}"
-  };
-  const labels = {
-    "slow-build": "Slow Build",
-    "many-dependencies": "Many Dependencies",
-    "circular-dependency": "Circular Dependency"
-  };
-  return `${icons[type]} ${labels[type]}`;
-};

package/dist/cmds/perf/utils/stats.d.ts

@@ -1,15 +0,0 @@
-import type { Statistics } from "../types.js";
-export declare const calculateStatistics: (values: number[]) => Statistics;
-export declare const percentile: (sorted: number[], p: number) => number;
-export declare const calculateMemoryGrowth: (initial: number, final: number) => number;
-export declare const calculateMemoryAverage: (measurements: number[]) => number;
-export declare const findPeakMemory: (measurements: number[]) => number;
-export declare const calculateImprovement: (baseline: number, current: number) => number;
-export declare const calculateRegression: (baseline: number, current: number) => number;
-export declare const isSignificantChange: (baseline: number, current: number, threshold?: number) => boolean;
-export declare const calculateConfidenceInterval: (values: number[], confidence?: number) => {
-    lower: number;
-    upper: number;
-};
-export declare const detectOutliers: (values: number[], threshold?: number) => number[];
-export declare const removeOutliers: (values: number[], threshold?: number) => number[];

package/dist/cmds/perf/utils/stats.js

@@ -1,101 +0,0 @@
-export const calculateStatistics = (values) => {
-  if (values.length === 0) {
-    return {
-      min: 0,
-      max: 0,
-      mean: 0,
-      median: 0,
-      p95: 0,
-      p99: 0,
-      variance: 0,
-      standardDeviation: 0,
-      coefficientOfVariation: 0
-    };
-  }
-  const sorted = [...values].sort((a, b) => a - b);
-  const n = values.length;
-  const min = sorted[0];
-  const max = sorted[n - 1];
-  const mean = values.reduce((sum, val) => sum + val, 0) / n;
-  const median = n % 2 === 0 ? (sorted[n / 2 - 1] + sorted[n / 2]) / 2 : sorted[Math.floor(n / 2)];
-  const p95 = percentile(sorted, 0.95);
-  const p99 = percentile(sorted, 0.99);
-  const variance = values.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / n;
-  const standardDeviation = Math.sqrt(variance);
-  const coefficientOfVariation = mean === 0 ? 0 : standardDeviation / mean;
-  return {
-    min,
-    max,
-    mean,
-    median,
-    p95,
-    p99,
-    variance,
-    standardDeviation,
-    coefficientOfVariation
-  };
-};
-export const percentile = (sorted, p) => {
-  if (sorted.length === 0) return 0;
-  if (sorted.length === 1) return sorted[0];
-  const index = p * (sorted.length - 1);
-  const lower = Math.floor(index);
-  const upper = Math.ceil(index);
-  if (lower === upper) {
-    return sorted[lower];
-  }
-  const weight = index - lower;
-  return sorted[lower] * (1 - weight) + sorted[upper] * weight;
-};
-export const calculateMemoryGrowth = (initial, final) => {
-  return final - initial;
-};
-export const calculateMemoryAverage = (measurements) => {
-  if (measurements.length === 0) return 0;
-  return measurements.reduce((sum, val) => sum + val, 0) / measurements.length;
-};
-export const findPeakMemory = (measurements) => {
-  return measurements.length === 0 ? 0 : Math.max(...measurements);
-};
-export const calculateImprovement = (baseline, current) => {
-  if (baseline === 0) return 0;
-  return (baseline - current) / baseline * 100;
-};
-export const calculateRegression = (baseline, current) => {
-  if (baseline === 0) return 0;
-  return (current - baseline) / baseline * 100;
-};
-export const isSignificantChange = (baseline, current, threshold = 5) => {
-  const change = Math.abs(calculateImprovement(baseline, current));
-  return change >= threshold;
-};
-export const calculateConfidenceInterval = (values, confidence = 0.95) => {
-  if (values.length < 2) {
-    return { lower: values[0] ?? 0, upper: values[0] ?? 0 };
-  }
-  const mean = values.reduce((sum, val) => sum + val, 0) / values.length;
-  const variance = values.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / (values.length - 1);
-  const standardError = Math.sqrt(variance / values.length);
-  const tValue = confidence === 0.95 ? 1.96 : 2.576;
-  const margin = tValue * standardError;
-  return {
-    lower: mean - margin,
-    upper: mean + margin
-  };
-};
-export const detectOutliers = (values, threshold = 2) => {
-  if (values.length < 3) return [];
-  const stats = calculateStatistics(values);
-  const outliers = [];
-  for (const value of values) {
-    const zScore = Math.abs((value - stats.mean) / stats.standardDeviation);
-    if (zScore > threshold) {
-      outliers.push(value);
-    }
-  }
-  return outliers;
-};
-export const removeOutliers = (values, threshold = 2) => {
-  const outliers = detectOutliers(values, threshold);
-  return values.filter((val) => !outliers.includes(val));
-};

package/dist/cmds/port/cmd.d.ts

@@ -1,2 +0,0 @@
-declare const _default: any;
-export default _default;