@reliverse/dler 2.2.5 → 2.2.10

package/package.json

@@ -2,27 +2,30 @@
   "name": "@reliverse/dler",
   "description": "@reliverse/dler is a framework which helps TypeScript and JavaScript developers create their libraries and CLI tools. It provides ready-to-use primitives, so you don't have to write them from scratch.",
   "author": "reliverse",
-  "version": "2.2.5",
+  "version": "2.2.10",
   "private": false,
   "type": "module",
   "bin": {
     "dler": "dist/cli.js"
   },
   "dependencies": {
-    "c12": "^3.3.2",
+    "c12": "^3.3.3",
     "semver": "^7.7.3",
     "lookpath": "^1.2.3",
-    "clipboardy": "^5.0.0",
-    "@reliverse/dler-publish": "^2.1.18",
-    "@reliverse/dler-bump": "^2.1.18",
-    "@reliverse/dler-build": "^2.1.18",
-    "@reliverse/dler-logger": "^2.1.18",
-    "@reliverse/dler-matcher": "^2.1.18",
-    "@reliverse/dler-launcher": "^2.1.18",
-    "@reliverse/dler-prompt": "^2.1.18",
-    "@reliverse/dler-helpers": "^2.1.18",
-    "@reliverse/dler-pkg-tsc": "^2.1.18",
-    "@reliverse/dler-mapper": "^2.1.18"
+    "clipboardy": "^5.0.2",
+    "@reliverse/datetime": "2.2.7",
+    "@reliverse/config": "2.2.7",
+    "@reliverse/publish": "2.2.7",
+    "@reliverse/bump": "2.2.7",
+    "@reliverse/build": "2.2.7",
+    "@reliverse/relinka": "2.2.7",
+    "@reliverse/matcha": "2.2.7",
+    "@reliverse/rempts": "2.2.7",
+    "@reliverse/helpers": "2.2.7",
+    "@reliverse/typerso": "2.2.7",
+    "@reliverse/relifso": "2.2.7",
+    "@reliverse/mapkit": "2.2.7",
+    "@reliverse/pathkit": "2.2.7"
   },
   "keywords": [
     "dler",

package/dist/cmds/perf/analysis/bundle.d.ts

@@ -1,20 +0,0 @@
-import type { BundleAnalysisResult } from "../types.js";
-export interface BundleAnalysisOptions {
-    target: string;
-    verbose?: boolean;
-    includeSourceMaps?: boolean;
-    analyzeDependencies?: boolean;
-}
-export declare class BundleAnalyzer {
-    private options;
-    constructor(options: BundleAnalysisOptions);
-    analyze(): Promise<BundleAnalysisResult>;
-    private findBundleFiles;
-    private analyzeFile;
-    private getFileType;
-    private extractModules;
-    private findDuplicates;
-    private calculateCompressionPotential;
-}
-export declare const analyzeBundle: (options: BundleAnalysisOptions) => Promise<BundleAnalysisResult>;
-export declare const createBundleAnalyzer: (options: BundleAnalysisOptions) => BundleAnalyzer;

package/dist/cmds/perf/analysis/bundle.js

@@ -1,225 +0,0 @@
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { extname, join, resolve } from "node:path";
-import { logger } from "@reliverse/dler-logger";
-export class BundleAnalyzer {
-  options;
-  constructor(options) {
-    this.options = options;
-  }
-  async analyze() {
-    const startTime = Date.now();
-    const { target, verbose } = this.options;
-    if (verbose) {
-      logger.info(`\u{1F50D} Analyzing bundle: ${target}`);
-    }
-    const targetPath = resolve(target);
-    if (!existsSync(targetPath)) {
-      throw new Error(`Target not found: ${target}`);
-    }
-    const stat = statSync(targetPath);
-    let files = [];
-    if (stat.isDirectory()) {
-      files = await this.findBundleFiles(targetPath);
-    } else {
-      files = [targetPath];
-    }
-    if (files.length === 0) {
-      throw new Error(`No bundle files found in: ${target}`);
-    }
-    if (verbose) {
-      logger.info(`   Found ${files.length} bundle files`);
-    }
-    const fileSizes = [];
-    const modules = [];
-    const duplicates = [];
-    for (const file of files) {
-      const fileSize = await this.analyzeFile(file);
-      fileSizes.push(fileSize);
-      if (this.options.analyzeDependencies) {
-        const fileModules = await this.extractModules(file);
-        modules.push(...fileModules);
-      }
-    }
-    fileSizes.sort((a, b) => b.size - a.size);
-    if (this.options.analyzeDependencies) {
-      const duplicateMap = this.findDuplicates(modules);
-      duplicates.push(...duplicateMap);
-    }
-    const totalSize = fileSizes.reduce((sum, file) => sum + file.size, 0);
-    const fileCount = fileSizes.length;
-    const compressionPotential = this.calculateCompressionPotential(files);
-    fileSizes.forEach((file) => {
-      file.percentage = file.size / totalSize * 100;
-    });
-    const analysisTime = Date.now() - startTime;
-    if (verbose) {
-      logger.info(`   Analysis completed in ${analysisTime}ms`);
-    }
-    return {
-      target,
-      totalSize,
-      fileCount,
-      largestFiles: fileSizes.slice(0, 10),
-      // Top 10
-      modules: modules.slice(0, 20),
-      // Top 20 modules
-      duplicates: duplicates.slice(0, 10),
-      // Top 10 duplicates
-      compressionPotential,
-      analysisTime
-    };
-  }
-  async findBundleFiles(dir) {
-    const bundleExtensions = [".js", ".mjs", ".cjs", ".ts", ".jsx", ".tsx"];
-    const files = [];
-    try {
-      const glob = new Bun.Glob("**/*");
-      const matches = glob.scanSync({ cwd: dir, onlyFiles: true });
-      for (const match of matches) {
-        const fullPath = join(dir, match);
-        const ext = extname(match);
-        if (bundleExtensions.includes(ext)) {
-          files.push(fullPath);
-        }
-      }
-    } catch (error) {
-      logger.warn(`Error scanning directory ${dir}:`, error);
-    }
-    return files;
-  }
-  async analyzeFile(filePath) {
-    const stat = statSync(filePath);
-    const ext = extname(filePath);
-    return {
-      path: filePath,
-      size: stat.size,
-      percentage: 0,
-      // Will be calculated later
-      type: this.getFileType(ext)
-    };
-  }
-  getFileType(extension) {
-    const typeMap = {
-      ".js": "JavaScript",
-      ".mjs": "ES Module",
-      ".cjs": "CommonJS",
-      ".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"
-    };
-    return typeMap[extension] ?? "Unknown";
-  }
-  async extractModules(filePath) {
-    const modules = [];
-    try {
-      const content = readFileSync(filePath, "utf-8");
-      const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
-      const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-      const dynamicImportRegex = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-      const dependencies = /* @__PURE__ */ new Set();
-      let match;
-      while ((match = importRegex.exec(content)) !== null) {
-        dependencies.add(match[1]);
-      }
-      while ((match = requireRegex.exec(content)) !== null) {
-        dependencies.add(match[1]);
-      }
-      while ((match = dynamicImportRegex.exec(content)) !== null) {
-        dependencies.add(match[1]);
-      }
-      for (const dep of dependencies) {
-        const isExternal = !dep.startsWith(".") && !dep.startsWith("/");
-        modules.push({
-          name: dep,
-          size: 0,
-          // Would need to resolve actual size
-          percentage: 0,
-          dependencies: [],
-          isExternal
-        });
-      }
-    } catch (error) {
-      logger.warn(`Error extracting modules from ${filePath}:`, error);
-    }
-    return modules;
-  }
-  findDuplicates(modules) {
-    const moduleMap = /* @__PURE__ */ new Map();
-    for (const module of modules) {
-      const key = module.name;
-      const existing = moduleMap.get(key);
-      if (existing) {
-        existing.count++;
-        existing.totalSize += module.size;
-        existing.locations.push(module.name);
-      } else {
-        moduleMap.set(key, {
-          count: 1,
-          totalSize: module.size,
-          locations: [module.name]
-        });
-      }
-    }
-    const duplicates = [];
-    for (const [name, info] of moduleMap) {
-      if (info.count > 1) {
-        duplicates.push({
-          name,
-          count: info.count,
-          totalSize: info.totalSize,
-          locations: info.locations
-        });
-      }
-    }
-    return duplicates.sort((a, b) => b.totalSize - a.totalSize);
-  }
-  calculateCompressionPotential(files) {
-    let totalSize = 0;
-    let compressibleSize = 0;
-    for (const file of files) {
-      const stat = statSync(file);
-      const ext = extname(file);
-      totalSize += stat.size;
-      const compressibleExtensions = [
-        ".js",
-        ".ts",
-        ".jsx",
-        ".tsx",
-        ".json",
-        ".css",
-        ".html",
-        ".svg"
-      ];
-      if (compressibleExtensions.includes(ext)) {
-        compressibleSize += stat.size;
-      }
-    }
-    if (totalSize === 0) return 0;
-    const estimatedCompression = compressibleSize * 0.7;
-    return estimatedCompression / totalSize * 100;
-  }
-}
-export const analyzeBundle = async (options) => {
-  const analyzer = new BundleAnalyzer(options);
-  return analyzer.analyze();
-};
-export const createBundleAnalyzer = (options) => {
-  return new BundleAnalyzer(options);
-};

package/dist/cmds/perf/analysis/filesystem.d.ts

@@ -1,27 +0,0 @@
-import type { FileSystemAnalysisResult } from "../types.js";
-export interface FileSystemAnalysisOptions {
-    target: string;
-    verbose?: boolean;
-    maxDepth?: number;
-    includeHidden?: boolean;
-    excludePatterns?: string[];
-}
-export declare class FileSystemAnalyzer {
-    private options;
-    private fileCount;
-    private totalSize;
-    private directoryCount;
-    private maxDepth;
-    private files;
-    private directories;
-    private fileTypes;
-    constructor(options: FileSystemAnalysisOptions);
-    analyze(): Promise<FileSystemAnalysisResult>;
-    private analyzeFile;
-    private analyzeDirectory;
-    private shouldExclude;
-    private getFileType;
-    private calculateCompressionPotential;
-}
-export declare const analyzeFileSystem: (options: FileSystemAnalysisOptions) => Promise<FileSystemAnalysisResult>;
-export declare const createFileSystemAnalyzer: (options: FileSystemAnalysisOptions) => FileSystemAnalyzer;

package/dist/cmds/perf/analysis/filesystem.js

@@ -1,245 +0,0 @@
-import { existsSync, statSync } from "node:fs";
-import { extname, join, resolve } from "node:path";
-import { logger } from "@reliverse/dler-logger";
-import { formatBytes } from "../utils/formatter.js";
-export class FileSystemAnalyzer {
-  options;
-  fileCount = 0;
-  totalSize = 0;
-  directoryCount = 0;
-  maxDepth = 0;
-  files = [];
-  directories = [];
-  fileTypes = /* @__PURE__ */ new Map();
-  constructor(options) {
-    this.options = options;
-  }
-  async analyze() {
-    const startTime = Date.now();
-    const { target, verbose } = this.options;
-    if (verbose) {
-      logger.info(`\u{1F50D} Analyzing filesystem: ${target}`);
-    }
-    const targetPath = resolve(target);
-    if (!existsSync(targetPath)) {
-      throw new Error(`Target not found: ${target}`);
-    }
-    const stat = statSync(targetPath);
-    if (stat.isFile()) {
-      await this.analyzeFile(targetPath, 0);
-    } else {
-      await this.analyzeDirectory(targetPath, 0);
-    }
-    this.files.sort((a, b) => b.size - a.size);
-    this.directories.sort((a, b) => b.size - a.size);
-    const fileTypeDistribution = Array.from(
-      this.fileTypes.entries()
-    ).map(([extension, info]) => ({
-      extension,
-      count: info.count,
-      totalSize: info.totalSize,
-      percentage: info.totalSize / this.totalSize * 100
-    })).sort((a, b) => b.totalSize - a.totalSize);
-    const compressionPotential = this.calculateCompressionPotential();
-    const analysisTime = Date.now() - startTime;
-    if (verbose) {
-      logger.info(`   Analysis completed in ${analysisTime}ms`);
-      logger.info(
-        `   Files: ${this.fileCount}, Directories: ${this.directoryCount}, Size: ${formatBytes(this.totalSize)}`
-      );
-    }
-    return {
-      target,
-      totalFiles: this.fileCount,
-      totalSize: this.totalSize,
-      directoryCount: this.directoryCount,
-      maxDepth: this.maxDepth,
-      largestFiles: this.files.slice(0, 20),
-      // Top 20
-      largestDirectories: this.directories.slice(0, 20),
-      // Top 20
-      fileTypes: fileTypeDistribution,
-      compressionPotential,
-      analysisTime
-    };
-  }
-  async analyzeFile(filePath, depth) {
-    try {
-      const stat = statSync(filePath);
-      const ext = extname(filePath);
-      if (this.shouldExclude(filePath)) {
-        return;
-      }
-      this.fileCount++;
-      this.totalSize += stat.size;
-      this.maxDepth = Math.max(this.maxDepth, depth);
-      this.files.push({
-        path: filePath,
-        size: stat.size,
-        percentage: 0,
-        // Will be calculated later
-        type: this.getFileType(ext)
-      });
-      const extension = ext || "no-extension";
-      const existing = this.fileTypes.get(extension);
-      if (existing) {
-        existing.count++;
-        existing.totalSize += stat.size;
-      } else {
-        this.fileTypes.set(extension, {
-          count: 1,
-          totalSize: stat.size
-        });
-      }
-    } catch (error) {
-      if (this.options.verbose) {
-        logger.warn(`Cannot access file ${filePath}:`, error);
-      }
-    }
-  }
-  async analyzeDirectory(dirPath, depth) {
-    try {
-      this.directoryCount++;
-      this.maxDepth = Math.max(this.maxDepth, depth);
-      if (this.shouldExclude(dirPath)) {
-        return;
-      }
-      let dirSize = 0;
-      let dirFileCount = 0;
-      const glob = new Bun.Glob("**/*");
-      const matches = glob.scanSync({
-        cwd: dirPath,
-        onlyFiles: false,
-        dot: this.options.includeHidden ?? false
-      });
-      for (const match of matches) {
-        const fullPath = join(dirPath, match);
-        try {
-          const stat = statSync(fullPath);
-          if (stat.isFile()) {
-            await this.analyzeFile(fullPath, depth + 1);
-            dirSize += stat.size;
-            dirFileCount++;
-          } else if (stat.isDirectory()) {
-            await this.analyzeDirectory(fullPath, depth + 1);
-          }
-        } catch (error) {
-          if (this.options.verbose) {
-            logger.warn(`Cannot access ${fullPath}:`, error);
-          }
-        }
-      }
-      this.directories.push({
-        path: dirPath,
-        size: dirSize,
-        fileCount: dirFileCount,
-        depth
-      });
-    } catch (error) {
-      if (this.options.verbose) {
-        logger.warn(`Cannot access directory ${dirPath}:`, error);
-      }
-    }
-  }
-  shouldExclude(path) {
-    const { excludePatterns = [] } = this.options;
-    for (const pattern of excludePatterns) {
-      if (path.includes(pattern)) {
-        return true;
-      }
-    }
-    const defaultExclusions = [
-      "node_modules",
-      ".git",
-      ".next",
-      ".expo",
-      "dist",
-      "build",
-      "coverage",
-      ".cache",
-      ".turbo"
-    ];
-    for (const exclusion of defaultExclusions) {
-      if (path.includes(exclusion)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  getFileType(extension) {
-    const typeMap = {
-      ".js": "JavaScript",
-      ".mjs": "ES Module",
-      ".cjs": "CommonJS",
-      ".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",
-      ".md": "Markdown",
-      ".txt": "Text",
-      ".yml": "YAML",
-      ".yaml": "YAML",
-      ".xml": "XML",
-      ".pdf": "PDF",
-      ".zip": "ZIP",
-      ".tar": "TAR",
-      ".gz": "GZIP"
-    };
-    return typeMap[extension] ?? "Unknown";
-  }
-  calculateCompressionPotential() {
-    if (this.totalSize === 0) return 0;
-    let compressibleSize = 0;
-    for (const [extension, info] of this.fileTypes) {
-      const compressibleExtensions = [
-        ".js",
-        ".mjs",
-        ".cjs",
-        ".ts",
-        ".jsx",
-        ".tsx",
-        ".json",
-        ".css",
-        ".scss",
-        ".sass",
-        ".less",
-        ".html",
-        ".svg",
-        ".md",
-        ".txt",
-        ".yml",
-        ".yaml",
-        ".xml"
-      ];
-      if (compressibleExtensions.includes(extension)) {
-        compressibleSize += info.totalSize;
-      }
-    }
-    const estimatedCompression = compressibleSize * 0.7;
-    return estimatedCompression / this.totalSize * 100;
-  }
-}
-export const analyzeFileSystem = async (options) => {
-  const analyzer = new FileSystemAnalyzer(options);
-  return analyzer.analyze();
-};
-export const createFileSystemAnalyzer = (options) => {
-  return new FileSystemAnalyzer(options);
-};

package/dist/cmds/perf/analysis/monorepo.d.ts

@@ -1,30 +0,0 @@
-import type { MonorepoAnalysisResult } from "../types.js";
-export interface MonorepoAnalysisOptions {
-    cwd?: string;
-    ignore?: string | string[];
-    verbose?: boolean;
-    includeDevDependencies?: boolean;
-    analyzeBuildOrder?: boolean;
-}
-export declare class MonorepoAnalyzer {
-    private options;
-    private packages;
-    private dependencyGraph;
-    constructor(options: MonorepoAnalysisOptions);
-    analyze(): Promise<MonorepoAnalysisResult>;
-    private findMonorepoRoot;
-    private discoverPackages;
-    private discoverSinglePackage;
-    private resolvePackageInfo;
-    private buildDependencyGraph;
-    private calculateLevels;
-    private findCircularDependencies;
-    private detectCycle;
-    private calculateCycleSeverity;
-    private calculateBuildOrder;
-    private findCriticalPath;
-    private identifyBottlenecks;
-    private suggestOptimalConcurrency;
-}
-export declare const analyzeMonorepo: (options: MonorepoAnalysisOptions) => Promise<MonorepoAnalysisResult>;
-export declare const createMonorepoAnalyzer: (options: MonorepoAnalysisOptions) => MonorepoAnalyzer;