@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/bundle-analyzer/collector.js

@@ -0,0 +1,233 @@
+import fs from "node:fs";
+import path from "node:path";
+import { gzipSync } from "node:zlib";
+import { createHash } from "node:crypto";
+const FILE_TYPE_MAP = {
+  ".js": "js",
+  ".mjs": "js",
+  ".cjs": "js",
+  ".ts": "js",
+  ".jsx": "js",
+  ".tsx": "js",
+  ".css": "css",
+  ".scss": "css",
+  ".sass": "css",
+  ".less": "css",
+  ".html": "html",
+  ".htm": "html",
+  ".png": "image",
+  ".jpg": "image",
+  ".jpeg": "image",
+  ".gif": "image",
+  ".svg": "image",
+  ".webp": "image",
+  ".avif": "image",
+  ".ico": "image",
+  ".woff": "font",
+  ".woff2": "font",
+  ".ttf": "font",
+  ".eot": "font",
+  ".otf": "font"
+}, VENDOR_PATTERNS = [
+  /node_modules/,
+  /vendor/,
+  /bower_components/,
+  /\.min\./
+], ENTRY_PATTERNS = [
+  /index\.(js|ts|html)$/,
+  /main\.(js|ts)$/,
+  /app\.(js|ts)$/,
+  /entry\.(js|ts)$/
+];
+export async function collectBundleStats(buildDir, options = {}) {
+  const {
+    includeSourceMaps = !1,
+    parseImports = !0,
+    detectDuplicates = !0,
+    topModulesCount = 20
+  } = options;
+  if (!fs.existsSync(buildDir))
+    throw Error(`Build directory not found: ${buildDir}`);
+  if (!fs.statSync(buildDir).isDirectory())
+    throw Error(`Not a directory: ${buildDir}`);
+  const files = await collectFiles(buildDir, includeSourceMaps), modules = [], warnings = [];
+  for (const filePath of files)
+    try {
+      const module = await processFile(filePath, buildDir, parseImports);
+      modules.push(module);
+    } catch (error) {
+      warnings.push(`Failed to process ${filePath}: ${error}`);
+    }
+  const chunks = groupIntoChunks(modules, buildDir), totalSize = modules.reduce((sum, m) => sum + m.size, 0), totalGzipSize = modules.reduce((sum, m) => sum + m.gzipSize, 0), byType = groupByType(modules), duplicates = detectDuplicates ? findDuplicates(modules) : [], largestModules = [...modules].sort((a, b) => b.size - a.size).slice(0, topModulesCount);
+  return {
+    timestamp: Date.now(),
+    buildDir: path.resolve(buildDir),
+    chunks,
+    totalSize,
+    totalGzipSize,
+    moduleCount: modules.length,
+    duplicates,
+    byType,
+    largestModules,
+    warnings
+  };
+}
+async function collectFiles(dir, includeSourceMaps) {
+  const files = [];
+  async function walk(currentDir) {
+    const entries = await fs.promises.readdir(currentDir, { withFileTypes: !0 });
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && entry.name !== "node_modules")
+          await walk(fullPath);
+      } else if (entry.isFile()) {
+        if (!includeSourceMaps && entry.name.endsWith(".map"))
+          continue;
+        files.push(fullPath);
+      }
+    }
+  }
+  await walk(dir);
+  return files;
+}
+async function processFile(filePath, buildDir, parseImports) {
+  const content = await fs.promises.readFile(filePath), relativePath = path.relative(buildDir, filePath), ext = path.extname(filePath).toLowerCase(), size = content.length, gzipSize = calculateGzipSize(content), parsedSize = estimateParsedSize(content, ext), hash = createHash("md5").update(content).digest("hex").slice(0, 8), type = FILE_TYPE_MAP[ext] || "other", imports = [];
+  if (parseImports && type === "js")
+    imports.push(...parseJsImports(content.toString("utf-8")));
+  return {
+    id: relativePath,
+    path: relativePath,
+    size,
+    gzipSize,
+    parsedSize,
+    extension: ext,
+    type,
+    imports,
+    importedBy: [],
+    hash
+  };
+}
+function calculateGzipSize(content) {
+  try {
+    const gzipLength = gzipSync(content, { level: 9 }).length;
+    return Math.min(gzipLength, content.length);
+  } catch {
+    return content.length;
+  }
+}
+function estimateParsedSize(content, ext) {
+  if (ext.includes(".min.") || content.length < 1000)
+    return content.length;
+  const type = FILE_TYPE_MAP[ext];
+  if (type === "js")
+    return Math.round(content.length * 0.6);
+  if (type === "css")
+    return Math.round(content.length * 0.7);
+  return content.length;
+}
+function parseJsImports(content) {
+  const imports = [], esImportRegex = /import\s+(?:[\w*{}\s,]+\s+from\s+)?['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = esImportRegex.exec(content)) !== null)
+    imports.push(match[1]);
+  const dynamicImportRegex = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  while ((match = dynamicImportRegex.exec(content)) !== null)
+    imports.push(match[1]);
+  const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  while ((match = requireRegex.exec(content)) !== null)
+    imports.push(match[1]);
+  return [...new Set(imports)];
+}
+function groupIntoChunks(modules, buildDir) {
+  const chunkMap = new Map;
+  for (const module of modules) {
+    const parts = module.path.split(path.sep);
+    let chunkName;
+    if (parts.length === 1)
+      chunkName = path.basename(module.path, module.extension);
+    else
+      chunkName = parts[0];
+    const existing = chunkMap.get(chunkName) || [];
+    existing.push(module);
+    chunkMap.set(chunkName, existing);
+  }
+  const chunks = [];
+  for (const [name, chunkModules] of chunkMap) {
+    const size = chunkModules.reduce((sum, m) => sum + m.size, 0), gzipSize = chunkModules.reduce((sum, m) => sum + m.gzipSize, 0), isEntry = chunkModules.some((m) => ENTRY_PATTERNS.some((p) => p.test(m.path))), isVendor = chunkModules.some((m) => VENDOR_PATTERNS.some((p) => p.test(m.path)));
+    chunks.push({
+      name,
+      files: chunkModules.map((m) => m.path),
+      modules: chunkModules,
+      size,
+      gzipSize,
+      isEntry,
+      isVendor
+    });
+  }
+  return chunks.sort((a, b) => b.size - a.size);
+}
+function groupByType(modules) {
+  const byType = {
+    js: { count: 0, size: 0, gzipSize: 0 },
+    css: { count: 0, size: 0, gzipSize: 0 },
+    html: { count: 0, size: 0, gzipSize: 0 },
+    image: { count: 0, size: 0, gzipSize: 0 },
+    font: { count: 0, size: 0, gzipSize: 0 },
+    other: { count: 0, size: 0, gzipSize: 0 }
+  };
+  for (const module of modules) {
+    byType[module.type].count++;
+    byType[module.type].size += module.size;
+    byType[module.type].gzipSize += module.gzipSize;
+  }
+  return byType;
+}
+function findDuplicates(modules) {
+  const hashMap = new Map;
+  for (const module of modules) {
+    const existing = hashMap.get(module.hash) || [];
+    existing.push(module);
+    hashMap.set(module.hash, existing);
+  }
+  const duplicates = [];
+  for (const [, sameHash] of hashMap)
+    if (sameHash.length > 1) {
+      const first = sameHash[0];
+      duplicates.push({
+        path: first.path,
+        count: sameHash.length,
+        wastedBytes: first.size * (sameHash.length - 1),
+        locations: sameHash.map((m) => m.path)
+      });
+    }
+  return duplicates.sort((a, b) => b.wastedBytes - a.wastedBytes);
+}
+export function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1048576)
+    return `${(bytes / 1024).toFixed(2)} KB`;
+  return `${(bytes / 1048576).toFixed(2)} MB`;
+}
+export function parseSize(size) {
+  const match = size.match(/^([\d.]+)\s*(B|KB|MB|GB)?$/i);
+  if (!match)
+    return 0;
+  const value = Number.parseFloat(match[1]);
+  switch ((match[2] || "B").toUpperCase()) {
+    case "KB":
+      return value * 1024;
+    case "MB":
+      return value * 1024 * 1024;
+    case "GB":
+      return value * 1024 * 1024 * 1024;
+    default:
+      return value;
+  }
+}
+export function percentage(part, total) {
+  if (total === 0)
+    return "0%";
+  return `${(part / total * 100).toFixed(1)}%`;
+}

package/dist/bundle-analyzer/index.d.ts

@@ -0,0 +1,98 @@
+import { collectBundleStats, formatBytes, parseSize, type CollectorOptions } from './collector';
+import { generateReport, analyzeBundle, type ReportOptions } from './report';
+import { generateTreemap, openInBrowser, type TreemapOptions } from './treemap';
+/**
+ * Analyze a bundle directory and generate a report
+ */
+// eslint-disable-next-line pickier/no-unused-vars
+export declare function analyze(options?: AnalyzeOptions): Promise<{
+  stats: ReturnType<typeof collectBundleStats> extends Promise<infer T> ? T : never
+  report: string
+  outputPath?: string
+  exceedsThreshold: boolean
+}>;
+/**
+ * Quick summary of bundle size
+ */
+// eslint-disable-next-line pickier/no-unused-vars
+export declare function getBundleSummary(directory: string): Promise<{
+  totalSize: number
+  totalSizeFormatted: string
+  gzipSize: number
+  gzipSizeFormatted: string
+  moduleCount: number
+  chunkCount: number
+}>;
+export declare interface AnalyzeOptions {
+  directory?: string
+  output?: string
+  format?: 'html' | 'json' | 'text' | 'markdown'
+  open?: boolean
+  gzip?: boolean
+  threshold?: string | number
+  recommendations?: boolean
+  topModules?: number
+  parseImports?: boolean
+}
+/**
+ * STX Bundle Analyzer
+ *
+ * Analyze and visualize bundle composition for optimization.
+ *
+ * @module bundle-analyzer
+ *
+ * @example
+ * ```bash
+ * # Generate HTML treemap
+ * stx analyze dist/
+ *
+ * # JSON output for CI
+ * stx analyze dist/ --json
+ *
+ * # Check size threshold
+ * stx analyze dist/ --threshold 500KB
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { collectBundleStats, generateReport, generateTreemap } from 'stx/bundle-analyzer'
+ *
+ * const stats = await collectBundleStats('dist/')
+ * console.log(generateReport(stats, { format: 'text' }))
+ * ```
+ */
+// ============================================================================
+// Collector Exports
+// ============================================================================
+export {
+  collectBundleStats,
+  formatBytes,
+  parseSize,
+  percentage,
+  type ModuleInfo,
+  type ModuleType,
+  type ChunkInfo,
+  type DuplicateModule,
+  type BundleStats,
+  type CollectorOptions,
+} from './collector';
+// ============================================================================
+// Report Exports
+// ============================================================================
+export {
+  generateReport,
+  analyzeBundle,
+  getModuleRecommendation,
+  type ReportOptions,
+  type AnalysisResult,
+  type AnalysisIssue,
+  type Recommendation,
+} from './report';
+// ============================================================================
+// Treemap Exports
+// ============================================================================
+export {
+  generateTreemap,
+  openInBrowser,
+  type TreemapOptions,
+} from './treemap';

package/dist/bundle-analyzer/index.js

@@ -0,0 +1,82 @@
+export {
+  collectBundleStats,
+  formatBytes,
+  parseSize,
+  percentage
+} from "./collector.js";
+export {
+  generateReport,
+  analyzeBundle,
+  getModuleRecommendation
+} from "./report.js";
+export {
+  generateTreemap,
+  openInBrowser
+} from "./treemap.js";
+import fs from "node:fs";
+import path from "node:path";
+import { collectBundleStats, formatBytes, parseSize } from "./collector.js";
+import { generateReport, analyzeBundle } from "./report.js";
+import { generateTreemap, openInBrowser } from "./treemap.js";
+export async function analyze(options = {}) {
+  const {
+    directory = "dist",
+    output,
+    format = "html",
+    open = !0,
+    gzip = !0,
+    threshold,
+    recommendations = !0,
+    topModules = 20,
+    parseImports = !0
+  } = options, stats = await collectBundleStats(directory, {
+    parseImports,
+    detectDuplicates: !0,
+    topModulesCount: topModules
+  }), thresholdBytes = threshold ? typeof threshold === "string" ? parseSize(threshold) : threshold : void 0, exceedsThreshold = thresholdBytes ? stats.totalSize > thresholdBytes : !1;
+  let report, outputPath;
+  if (format === "html") {
+    const treemapOptions = {
+      title: `Bundle Analysis - ${path.basename(path.resolve(directory))}`,
+      gzip
+    };
+    report = generateTreemap(stats, treemapOptions);
+    outputPath = output || path.join(directory, "bundle-report.html");
+    await fs.promises.writeFile(outputPath, report);
+    if (open)
+      openInBrowser(outputPath);
+  } else {
+    report = generateReport(stats, {
+      format,
+      threshold: thresholdBytes,
+      recommendations,
+      topModules,
+      showGzip: gzip
+    });
+    if (output) {
+      outputPath = output;
+      await fs.promises.writeFile(outputPath, report);
+    }
+  }
+  return {
+    stats,
+    report,
+    outputPath,
+    exceedsThreshold
+  };
+}
+export async function getBundleSummary(directory) {
+  const stats = await collectBundleStats(directory, {
+    parseImports: !1,
+    detectDuplicates: !1,
+    topModulesCount: 0
+  });
+  return {
+    totalSize: stats.totalSize,
+    totalSizeFormatted: formatBytes(stats.totalSize),
+    gzipSize: stats.totalGzipSize,
+    gzipSizeFormatted: formatBytes(stats.totalGzipSize),
+    moduleCount: stats.moduleCount,
+    chunkCount: stats.chunks.length
+  };
+}

package/dist/bundle-analyzer/report.d.ts

@@ -0,0 +1,39 @@
+import type { BundleStats } from './collector';
+/**
+ * Generate a report from bundle statistics
+ */
+export declare function generateReport(stats: BundleStats, options: ReportOptions): string;
+/**
+ * Analyze bundle for issues and recommendations
+ */
+export declare function analyzeBundle(stats: BundleStats, options: ReportOptions): AnalysisResult;
+/**
+ * Get recommendations for a specific module
+ */
+export declare function getModuleRecommendation(modulePath: string): Recommendation | null;
+// ============================================================================
+// Types
+// ============================================================================
+export declare interface ReportOptions {
+  format: 'text' | 'json' | 'markdown'
+  threshold?: number
+  recommendations?: boolean
+  topModules?: number
+  showGzip?: boolean
+}
+export declare interface AnalysisResult {
+  score: number
+  issues: AnalysisIssue[]
+  recommendations: Recommendation[]
+}
+export declare interface AnalysisIssue {
+  severity: 'error' | 'warning' | 'info'
+  message: string
+  details?: string
+}
+export declare interface Recommendation {
+  title: string
+  description: string
+  impact: 'high' | 'medium' | 'low'
+  effort: 'low' | 'medium' | 'high'
+}