@ecrindigital/facetpack 0.1.10 → 0.2.0

package/dist/serializer.js

@@ -6,15 +6,277 @@ import {
   analyzeSync,
   shakeSync
 } from "@ecrindigital/facetpack-native";
+
+// src/stats.ts
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+var ANSI = {
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  reset: "\x1B[0m"
+};
+var STATS_DIR = join(tmpdir(), "facetpack-stats");
+var STATS_FILE_PREFIX = "stats-";
+var LOCK_FILE = join(STATS_DIR, ".print-lock");
+var PRINT_DELAY = 1000;
+function getStatsFilePath() {
+  const workerId = process.env.METRO_WORKER_ID || process.pid.toString();
+  return join(STATS_DIR, `${STATS_FILE_PREFIX}${workerId}.json`);
+}
+function ensureStatsDir() {
+  if (!existsSync(STATS_DIR)) {
+    mkdirSync(STATS_DIR, { recursive: true });
+  }
+}
+function acquirePrintLock() {
+  try {
+    ensureStatsDir();
+    if (existsSync(LOCK_FILE)) {
+      const lockTime = parseInt(readFileSync(LOCK_FILE, "utf-8"), 10);
+      if (Date.now() - lockTime < 5000) {
+        return false;
+      }
+    }
+    writeFileSync(LOCK_FILE, Date.now().toString());
+    return true;
+  } catch {
+    return false;
+  }
+}
+function releasePrintLock() {
+  try {
+    if (existsSync(LOCK_FILE)) {
+      unlinkSync(LOCK_FILE);
+    }
+  } catch {}
+}
+
+class GlobalStats {
+  stats = this.createEmptyStats();
+  exitHandlerRegistered = false;
+  hasPrinted = false;
+  printTimer = null;
+  createEmptyStats() {
+    return {
+      transformer: { oxc: 0, babel: 0 },
+      resolver: { facetpack: 0, metro: 0 },
+      minifier: { files: 0, originalSize: 0, minifiedSize: 0 },
+      treeShaking: { modulesAnalyzed: 0, modulesRemoved: 0, exportsRemoved: 0 },
+      startTime: Date.now()
+    };
+  }
+  recordTransform(engine) {
+    this.stats.transformer[engine]++;
+    this.persistStats();
+    this.schedulePrint();
+  }
+  adjustTransformFallback() {
+    this.stats.transformer.oxc--;
+    this.stats.transformer.babel++;
+    this.persistStats();
+  }
+  recordResolve(engine) {
+    this.stats.resolver[engine]++;
+  }
+  flush() {
+    this.persistStats();
+  }
+  schedulePrint() {
+    if (this.printTimer) {
+      clearTimeout(this.printTimer);
+    }
+    this.printTimer = setTimeout(() => {
+      if (acquirePrintLock()) {
+        this.print();
+        releasePrintLock();
+      }
+    }, PRINT_DELAY);
+  }
+  recordMinify(originalSize, minifiedSize) {
+    this.stats.minifier.files++;
+    this.stats.minifier.originalSize += originalSize;
+    this.stats.minifier.minifiedSize += minifiedSize;
+  }
+  recordTreeShaking(analyzed, removed, exports) {
+    this.stats.treeShaking.modulesAnalyzed += analyzed;
+    this.stats.treeShaking.modulesRemoved += removed;
+    this.stats.treeShaking.exportsRemoved += exports;
+  }
+  get() {
+    return JSON.parse(JSON.stringify(this.stats));
+  }
+  reset() {
+    this.stats = this.createEmptyStats();
+    this.hasPrinted = false;
+    this.cleanupStatsFiles();
+  }
+  persistStats() {
+    try {
+      ensureStatsDir();
+      writeFileSync(getStatsFilePath(), JSON.stringify(this.stats));
+    } catch {}
+  }
+  cleanupStatsFiles() {
+    try {
+      if (existsSync(STATS_DIR)) {
+        const { readdirSync } = __require("fs");
+        const files = readdirSync(STATS_DIR);
+        for (const file of files) {
+          if (file.startsWith(STATS_FILE_PREFIX)) {
+            try {
+              unlinkSync(join(STATS_DIR, file));
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+  }
+  aggregateWorkerStats() {
+    const aggregated = this.createEmptyStats();
+    aggregated.startTime = this.stats.startTime;
+    try {
+      if (existsSync(STATS_DIR)) {
+        const { readdirSync } = __require("fs");
+        const files = readdirSync(STATS_DIR);
+        for (const file of files) {
+          if (file.startsWith(STATS_FILE_PREFIX)) {
+            try {
+              const content = readFileSync(join(STATS_DIR, file), "utf-8");
+              const workerStats = JSON.parse(content);
+              aggregated.transformer.oxc += workerStats.transformer.oxc;
+              aggregated.transformer.babel += workerStats.transformer.babel;
+              aggregated.resolver.facetpack += workerStats.resolver.facetpack;
+              aggregated.resolver.metro += workerStats.resolver.metro;
+              if (workerStats.startTime < aggregated.startTime) {
+                aggregated.startTime = workerStats.startTime;
+              }
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+    aggregated.minifier = this.stats.minifier;
+    aggregated.treeShaking = this.stats.treeShaking;
+    return aggregated;
+  }
+  formatPercent(value, total) {
+    if (total === 0)
+      return "0.0";
+    return (value / total * 100).toFixed(1);
+  }
+  formatSize(bytes) {
+    if (bytes < 1024)
+      return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+      return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+  }
+  formatDuration(ms) {
+    if (ms < 1000)
+      return `${ms}ms`;
+    return `${(ms / 1000).toFixed(2)}s`;
+  }
+  print() {
+    if (!process.env.FACETPACK_DEBUG || this.hasPrinted)
+      return;
+    const aggregated = this.aggregateWorkerStats();
+    const { transformer, resolver, minifier, treeShaking, startTime } = aggregated;
+    const duration = Date.now() - startTime;
+    const transformTotal = transformer.oxc + transformer.babel;
+    const resolveTotal = resolver.facetpack + resolver.metro;
+    if (transformTotal === 0 && resolveTotal === 0 && minifier.files === 0)
+      return;
+    this.hasPrinted = true;
+    const { cyan, green, yellow, white, gray, bold, dim, reset } = ANSI;
+    console.log(`
+`);
+    console.log(`${bold}${cyan}╔════════════════════════════════════════════════════════════════════╗${reset}`);
+    console.log(`${bold}${cyan}║${reset}                    ${bold}FACETPACK BUNDLE STATS${reset}                         ${cyan}║${reset}`);
+    console.log(`${bold}${cyan}╠════════════════════════════════════════════════════════════════════╣${reset}`);
+    if (transformTotal > 0) {
+      const oxcPct = this.formatPercent(transformer.oxc, transformTotal);
+      const babelPct = this.formatPercent(transformer.babel, transformTotal);
+      console.log(`${cyan}║${reset}                                                                    ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${bold}TRANSFORMER${reset}                                                      ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${green}●${reset} OXC (native)    ${bold}${green}${transformer.oxc.toString().padStart(6)}${reset} files   ${green}${oxcPct.padStart(6)}%${reset}                 ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${yellow}●${reset} Babel           ${bold}${yellow}${transformer.babel.toString().padStart(6)}${reset} files   ${yellow}${babelPct.padStart(6)}%${reset}                 ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${dim}${white}  Total           ${transformTotal.toString().padStart(6)} files${reset}                            ${cyan}║${reset}`);
+    }
+    if (resolveTotal > 0) {
+      const fpPct = this.formatPercent(resolver.facetpack, resolveTotal);
+      const metroPct = this.formatPercent(resolver.metro, resolveTotal);
+      console.log(`${cyan}║${reset}                                                                    ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${bold}RESOLVER${reset}                                                         ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${green}●${reset} Facetpack       ${bold}${green}${resolver.facetpack.toString().padStart(6)}${reset} hits    ${green}${fpPct.padStart(6)}%${reset}                 ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${yellow}●${reset} Metro           ${bold}${yellow}${resolver.metro.toString().padStart(6)}${reset} hits    ${yellow}${metroPct.padStart(6)}%${reset}                 ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${dim}${white}  Total           ${resolveTotal.toString().padStart(6)} resolutions${reset}                      ${cyan}║${reset}`);
+    }
+    if (minifier.files > 0) {
+      const savings = minifier.originalSize - minifier.minifiedSize;
+      const savingsPct = this.formatPercent(savings, minifier.originalSize);
+      console.log(`${cyan}║${reset}                                                                    ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${bold}MINIFIER${reset}                                                         ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${green}●${reset} Files minified  ${bold}${green}${minifier.files.toString().padStart(6)}${reset}                                   ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${gray}●${reset} Original size   ${this.formatSize(minifier.originalSize).padStart(12)}                             ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${green}●${reset} Minified size   ${this.formatSize(minifier.minifiedSize).padStart(12)}  ${green}-${savingsPct}%${reset}                    ${cyan}║${reset}`);
+    }
+    if (treeShaking.modulesAnalyzed > 0) {
+      console.log(`${cyan}║${reset}                                                                    ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${bold}TREE SHAKING${reset}                                                     ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${gray}●${reset} Modules analyzed ${bold}${treeShaking.modulesAnalyzed.toString().padStart(5)}${reset}                                   ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${green}●${reset} Modules removed  ${bold}${green}${treeShaking.modulesRemoved.toString().padStart(5)}${reset}                                   ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${green}●${reset} Exports removed  ${bold}${green}${treeShaking.exportsRemoved.toString().padStart(5)}${reset}                                   ${cyan}║${reset}`);
+    }
+    console.log(`${cyan}║${reset}                                                                    ${cyan}║${reset}`);
+    console.log(`${cyan}║${reset}  ${dim}Duration: ${this.formatDuration(duration)}${reset}                                             ${cyan}║${reset}`);
+    console.log(`${bold}${cyan}╚════════════════════════════════════════════════════════════════════╝${reset}`);
+    console.log(`
+`);
+    this.cleanupStatsFiles();
+  }
+  registerExitHandler() {
+    if (this.exitHandlerRegistered)
+      return;
+    this.exitHandlerRegistered = true;
+    process.on("SIGINT", () => {
+      this.print();
+      process.exit(0);
+    });
+    process.on("beforeExit", () => this.print());
+  }
+}
+var globalStats = new GlobalStats;
+function printStats() {
+  globalStats.print();
+}
+function resetStats() {
+  globalStats.reset();
+}
+function getStats() {
+  return globalStats.get();
+}
+
+// src/serializer.ts
 function createFacetpackSerializer(existingSerializer, config = {}) {
   return async (entryPoint, preModules, graph, options) => {
     if (options.dev || config.treeShake === false) {
+      let result2;
       if (existingSerializer) {
-        return existingSerializer(entryPoint, preModules, graph, options);
+        result2 = await existingSerializer(entryPoint, preModules, graph, options);
+      } else {
+        result2 = defaultSerialize(entryPoint, preModules, graph, options);
       }
-      return defaultSerialize(entryPoint, preModules, graph, options);
+      globalStats.print();
+      return result2;
     }
     const analyses = new Map;
+    let modulesAnalyzed = 0;
     for (const [path, module] of graph.dependencies) {
       if (path.includes("node_modules")) {
         continue;
@@ -23,6 +285,7 @@ function createFacetpackSerializer(existingSerializer, config = {}) {
         const code = module.output[0]?.data?.code ?? "";
         const analysis = analyzeSync(path, code);
         analyses.set(path, analysis);
+        modulesAnalyzed++;
       } catch {
         analyses.set(path, {
           exports: [],
@@ -33,7 +296,8 @@ function createFacetpackSerializer(existingSerializer, config = {}) {
     }
     const usedExports = computeUsedExports(entryPoint, analyses, graph);
     const shakenModules = new Map;
-    let totalRemoved = 0;
+    let modulesRemoved = 0;
+    let exportsRemoved = 0;
     for (const [path, module] of graph.dependencies) {
       if (path.includes("node_modules")) {
         const code = module.output[0]?.data?.code ?? "";
@@ -43,28 +307,30 @@ function createFacetpackSerializer(existingSerializer, config = {}) {
       const used = usedExports.get(path);
       const analysis = analyses.get(path);
       if ((!used || used.size === 0) && analysis && !analysis.hasSideEffects) {
-        totalRemoved++;
+        modulesRemoved++;
         continue;
       }
       try {
         const code = module.output[0]?.data?.code ?? "";
         const usedArray = used ? Array.from(used) : ["*"];
-        const result = shakeSync(path, code, usedArray);
-        shakenModules.set(path, { code: result.code, map: result.map ?? undefined });
-        totalRemoved += result.removedExports.length;
+        const result2 = shakeSync(path, code, usedArray);
+        shakenModules.set(path, { code: result2.code, map: result2.map ?? undefined });
+        exportsRemoved += result2.removedExports.length;
       } catch {
         const code = module.output[0]?.data?.code ?? "";
         shakenModules.set(path, { code });
       }
     }
-    if (totalRemoved > 0) {
-      console.log(`[facetpack] Tree-shaking removed ${totalRemoved} unused exports`);
-    }
+    globalStats.recordTreeShaking(modulesAnalyzed, modulesRemoved, exportsRemoved);
+    let result;
     if (existingSerializer) {
       const shakenGraph = createShakenGraph(graph, shakenModules);
-      return existingSerializer(entryPoint, preModules, shakenGraph, options);
+      result = await existingSerializer(entryPoint, preModules, shakenGraph, options);
+    } else {
+      result = defaultSerialize(entryPoint, preModules, graph, options, shakenModules);
     }
-    return defaultSerialize(entryPoint, preModules, graph, options, shakenModules);
+    globalStats.print();
+    return result;
   };
 }
 function computeUsedExports(entryPoint, analyses, graph) {

package/dist/stats.d.ts

@@ -0,0 +1,55 @@
+interface TransformerStats {
+    oxc: number;
+    babel: number;
+}
+interface ResolverStats {
+    facetpack: number;
+    metro: number;
+}
+interface MinifierStats {
+    files: number;
+    originalSize: number;
+    minifiedSize: number;
+}
+interface TreeShakingStats {
+    modulesAnalyzed: number;
+    modulesRemoved: number;
+    exportsRemoved: number;
+}
+interface FacetpackStats {
+    transformer: TransformerStats;
+    resolver: ResolverStats;
+    minifier: MinifierStats;
+    treeShaking: TreeShakingStats;
+    startTime: number;
+}
+declare class GlobalStats {
+    private stats;
+    private exitHandlerRegistered;
+    private hasPrinted;
+    private printTimer;
+    private createEmptyStats;
+    recordTransform(engine: 'oxc' | 'babel'): void;
+    adjustTransformFallback(): void;
+    recordResolve(engine: 'facetpack' | 'metro'): void;
+    flush(): void;
+    schedulePrint(): void;
+    recordMinify(originalSize: number, minifiedSize: number): void;
+    recordTreeShaking(analyzed: number, removed: number, exports: number): void;
+    get(): FacetpackStats;
+    reset(): void;
+    private persistStats;
+    private cleanupStatsFiles;
+    aggregateWorkerStats(): FacetpackStats;
+    private formatPercent;
+    private formatSize;
+    private formatDuration;
+    print(): void;
+    registerExitHandler(): void;
+}
+export declare const globalStats: GlobalStats;
+export declare function printStats(): void;
+export declare function resetStats(): void;
+export declare function getStats(): FacetpackStats;
+export {};
+//# sourceMappingURL=stats.d.ts.map

package/dist/stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../src/stats.ts"],"names":[],"mappings":"AAeA,UAAU,gBAAgB;IACxB,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;CACd;AAED,UAAU,aAAa;IACrB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;CACd;AAED,UAAU,aAAa;IACrB,KAAK,EAAE,MAAM,CAAA;IACb,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;CACrB;AAED,UAAU,gBAAgB;IACxB,eAAe,EAAE,MAAM,CAAA;IACvB,cAAc,EAAE,MAAM,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;CACvB;AAED,UAAU,cAAc;IACtB,WAAW,EAAE,gBAAgB,CAAA;IAC7B,QAAQ,EAAE,aAAa,CAAA;IACvB,QAAQ,EAAE,aAAa,CAAA;IACvB,WAAW,EAAE,gBAAgB,CAAA;IAC7B,SAAS,EAAE,MAAM,CAAA;CAClB;AA0CD,cAAM,WAAW;IACf,OAAO,CAAC,KAAK,CAA0C;IACvD,OAAO,CAAC,qBAAqB,CAAQ;IACrC,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,UAAU,CAA6C;IAE/D,OAAO,CAAC,gBAAgB;IAUxB,eAAe,CAAC,MAAM,EAAE,KAAK,GAAG,OAAO,GAAG,IAAI;IAM9C,uBAAuB,IAAI,IAAI;IAM/B,aAAa,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,GAAG,IAAI;IAIlD,KAAK,IAAI,IAAI;IAIb,aAAa,IAAI,IAAI;IAYrB,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAM9D,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAM3E,GAAG,IAAI,cAAc;IAIrB,KAAK,IAAI,IAAI;IAMb,OAAO,CAAC,YAAY;IAOpB,OAAO,CAAC,iBAAiB;IAgBzB,oBAAoB,IAAI,cAAc;IAmCtC,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,cAAc;IAKtB,KAAK,IAAI,IAAI;IAmEb,mBAAmB,IAAI,IAAI;CAU5B;AAED,eAAO,MAAM,WAAW,aAAoB,CAAA;AAE5C,wBAAgB,UAAU,IAAI,IAAI,CAEjC;AAED,wBAAgB,UAAU,IAAI,IAAI,CAEjC;AAED,wBAAgB,QAAQ,IAAI,cAAc,CAEzC"}