@openelement/ssg 0.41.0-alpha.1

package/src/ssg-report.js

@@ -0,0 +1,172 @@
+/**
+ * @openelement/ssg - DSD report assembly
+ *
+ * Builds the dsd-report.json contents from render diagnostics,
+ * hydration strategy summary, manifest decisions, and CEM
+ * compatibility classifications.
+ */ import { join } from 'node:path';
+import { writeFileSync } from 'node:fs';
+import { createLogger } from '@openelement/core/logger';
+import { writeJson } from '@openelement/content/write-json';
+const log = createLogger('ssg');
+// ─── Hydration Strategy Summary ────────────────────────────────
+/**
+ * Build a summary of hydration strategies used across all components.
+ */ export function buildHydrationStrategySummary(evidence) {
+  const summary = {
+    load: 0,
+    idle: 0,
+    visible: 0,
+    only: 0,
+    clientOnlyExcluded: 0
+  };
+  const decisions = evidence.admissionDecisions || [];
+  const localMeta = evidence.localIslandMeta || {};
+  for (const meta of Object.values(localMeta)){
+    const strategy = meta.hydrate || 'idle';
+    if (strategy in summary) {
+      summary[strategy]++;
+    }
+  }
+  for (const decl of evidence.packageIslandDecls || []){
+    const strategy = decl.hydrate || 'idle';
+    if (strategy in summary) {
+      summary[strategy]++;
+    }
+  }
+  summary.clientOnlyExcluded = decisions.filter((d)=>d.renderPath === 'client-only').length;
+  return summary;
+}
+// ─── Manifest Decisions Builder (v0.17.2) ───────────────────────
+/**
+ * Build manifest-driven render decisions from ctx.
+ *
+ * For each package island declaration, records how the pipeline resolved
+ * manifest flags (ssr, dsd, hydrate) into a concrete render path:
+ * - 'ssr+client': component is SSR-rendered + client-upgraded
+ * - 'client-only': component is client-only (ssr === false)
+ *
+ * When ctx or packageIslandDecls is absent, returns an empty array.
+ */ export function buildManifestDecisions(evidence) {
+  const decls = evidence.packageIslandDecls;
+  const manifests = evidence.packageManifests;
+  if (!decls?.length || !manifests?.length) return [];
+  // Build a tagName -> packageName lookup from manifests
+  const tagNameToPackage = new Map();
+  for (const pkg of manifests){
+    for (const decl of pkg.declarations){
+      tagNameToPackage.set(decl.tagName, pkg.packageName);
+    }
+  }
+  return decls.map((island)=>{
+    const admission = evidence.admissionDecisions?.find((d)=>d.tagName === island.tagName);
+    const ssr = admission?.renderPath === 'ssr+client';
+    const dsd = island.dsd !== false; // default: true
+    const renderPath = ssr ? 'ssr+client' : 'client-only';
+    return {
+      tagName: island.tagName,
+      packageName: tagNameToPackage.get(island.tagName) || 'unknown',
+      ssr,
+      dsd,
+      hydrate: island.hydrate,
+      renderPath,
+      reason: admission?.reason,
+      source: 'package'
+    };
+  });
+}
+// ─── CEM Compatibility Report Builder (v0.18.0) ─────────────────
+/**
+ * Build a CEM compatibility report from CEM classifications.
+ *
+ * Summarizes how the compatibility classifier classified each third-party
+ * WC package component into a tier (ssr-capable, client-only, rejected,
+ * experimental-dom). Written to dsd-report.json for CI assertion.
+ *
+ * Returns undefined when no CEM classifications exist.
+ */ export function buildCemCompatibilityReport(classifications) {
+  if (!classifications?.length) return undefined;
+  const ssrCapableCount = classifications.filter((c)=>c.tier === 'ssr-capable').length;
+  const clientOnlyCount = classifications.filter((c)=>c.tier === 'client-only').length;
+  const rejectedCount = classifications.filter((c)=>c.tier === 'rejected').length;
+  const experimentalDomCount = classifications.filter((c)=>c.tier === 'experimental-dom').length;
+  // Order: rejected first (most critical), then ssr-capable, client-only, experimental-dom
+  const sortedClassifications = [
+    ...classifications
+  ].sort((a, b)=>{
+    const tierOrder = {
+      rejected: 0,
+      'ssr-capable': 1,
+      'client-only': 2,
+      'experimental-dom': 3
+    };
+    return (tierOrder[a.tier] ?? 99) - (tierOrder[b.tier] ?? 99);
+  });
+  const summaryParts = [];
+  if (ssrCapableCount > 0) summaryParts.push(`${ssrCapableCount} ssr-capable`);
+  if (clientOnlyCount > 0) summaryParts.push(`${clientOnlyCount} client-only`);
+  if (rejectedCount > 0) summaryParts.push(`${rejectedCount} rejected`);
+  if (experimentalDomCount > 0) summaryParts.push(`${experimentalDomCount} experimental-dom`);
+  return {
+    totalClassified: classifications.length,
+    ssrCapableCount,
+    clientOnlyCount,
+    rejectedCount,
+    experimentalDomCount,
+    classifications: sortedClassifications,
+    summary: summaryParts.length > 0 ? `CEM: ${summaryParts.join(', ')}` : 'CEM: no components classified'
+  };
+}
+// ─── Report Assembly ────────────────────────────────────────────
+/**
+ * Assemble the full dsd-report.json object from page diagnostics and evidence.
+ */ export function assembleDsdReport(pageDiagnostics, evidence) {
+  const totalErrors = pageDiagnostics.reduce((sum, p)=>sum + p.errors.length, 0);
+  const totalComponents = pageDiagnostics.reduce((sum, p)=>sum + p.componentCount, 0);
+  const totalRenderTimeMs = pageDiagnostics.reduce((sum, p)=>sum + p.renderTimeMs, 0);
+  const totalTemplateSize = pageDiagnostics.reduce((sum, p)=>sum + p.hydrationHints.length, 0);
+  const errorComponentCount = pageDiagnostics.filter((p)=>p.errors.length > 0).length;
+  const maxNestingDepth = 0; // Determined from collector, not per-page
+  const interactiveCount = pageDiagnostics.reduce((sum, p)=>sum + p.hydrationHints.filter((h)=>h.layer === 'dsd-interactive').length, 0);
+  const pureIslandCount = pageDiagnostics.reduce((sum, p)=>sum + p.hydrationHints.filter((h)=>h.layer === 'pure-island').length, 0);
+  const totalHints = pageDiagnostics.reduce((sum, p)=>sum + p.hydrationHints.length, 0);
+  const strategySummary = buildHydrationStrategySummary(evidence);
+  return {
+    reportVersion: '1.2.0',
+    timestamp: new Date().toISOString(),
+    totalPages: pageDiagnostics.length,
+    totalErrors,
+    renderErrors: pageDiagnostics.map((p)=>({
+        path: p.path,
+        errors: p.errors,
+        hydrationHints: p.hydrationHints,
+        componentCount: p.componentCount,
+        renderTimeMs: p.renderTimeMs
+      })),
+    metricsSummary: {
+      totalComponents,
+      totalRenderTimeMs,
+      avgRenderTimeMs: totalComponents > 0 ? Math.round(totalRenderTimeMs / totalComponents * 100) / 100 : 0,
+      totalTemplateSize,
+      maxNestingDepth,
+      errorComponentCount
+    },
+    hydrationHintSummary: {
+      totalHints,
+      interactiveCount,
+      pureIslandCount
+    },
+    hydrationStrategySummary: strategySummary,
+    manifestDecisions: buildManifestDecisions(evidence),
+    admissionDecisions: evidence.admissionDecisions || [],
+    cemCompatibility: buildCemCompatibilityReport(evidence.cemClassifications)
+  };
+}
+/**
+ * Write the DSD report to the output directory.
+ */ export function writeDsdReport(outputDir, report) {
+  const reportPath = join(outputDir, 'dsd-report.json');
+  writeFileSync(reportPath, writeJson(report), 'utf-8');
+  log.info(`DSD report -> ${reportPath} (${report.totalPages} pages, ${report.totalErrors} errors)`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/ssg/src/ssg-report.ts"],"sourcesContent":["/**\n * @openelement/ssg - DSD report assembly\n *\n * Builds the dsd-report.json contents from render diagnostics,\n * hydration strategy summary, manifest decisions, and CEM\n * compatibility classifications.\n */\n\nimport { join } from 'node:path';\nimport { writeFileSync } from 'node:fs';\nimport { createLogger } from '@openelement/core/logger';\nimport { writeJson } from '@openelement/content/write-json';\nimport type { CemCompatibilityReport } from '@openelement/protocol/manifest';\nimport type { CompatibilityClassification } from '@openelement/protocol/framework';\nimport type {\n  DsdBuildReport,\n  DsdHydrationStrategySummary,\n  ManifestDecision,\n} from '@openelement/protocol/render';\nimport type { SsgRenderEvidence } from '@openelement/protocol/ssg';\nimport type { PageDiagnostic } from './ssg-helpers.js';\n\nconst log = createLogger('ssg');\n\n// ─── Hydration Strategy Summary ────────────────────────────────\n\n/**\n * Build a summary of hydration strategies used across all components.\n */\nexport function buildHydrationStrategySummary(\n  evidence: SsgRenderEvidence,\n): DsdHydrationStrategySummary {\n  const summary: DsdHydrationStrategySummary = {\n    load: 0,\n    idle: 0,\n    visible: 0,\n    only: 0,\n    clientOnlyExcluded: 0,\n  };\n  const decisions = evidence.admissionDecisions || [];\n  const localMeta = evidence.localIslandMeta || {};\n\n  for (const meta of Object.values(localMeta)) {\n    const strategy = meta.hydrate || 'idle';\n    if (strategy in summary) {\n      summary[strategy as keyof typeof summary]++;\n    }\n  }\n  for (const decl of evidence.packageIslandDecls || []) {\n    const strategy = decl.hydrate || 'idle';\n    if (strategy in summary) {\n      summary[strategy as keyof typeof summary]++;\n    }\n  }\n  summary.clientOnlyExcluded = decisions.filter((d) => d.renderPath === 'client-only').length;\n  return summary;\n}\n\n// ─── Manifest Decisions Builder (v0.17.2) ───────────────────────\n\n/**\n * Build manifest-driven render decisions from ctx.\n *\n * For each package island declaration, records how the pipeline resolved\n * manifest flags (ssr, dsd, hydrate) into a concrete render path:\n * - 'ssr+client': component is SSR-rendered + client-upgraded\n * - 'client-only': component is client-only (ssr === false)\n *\n * When ctx or packageIslandDecls is absent, returns an empty array.\n */\nexport function buildManifestDecisions(\n  evidence: SsgRenderEvidence,\n): ManifestDecision[] {\n  const decls = evidence.packageIslandDecls;\n  const manifests = evidence.packageManifests;\n  if (!decls?.length || !manifests?.length) return [];\n\n  // Build a tagName -> packageName lookup from manifests\n  const tagNameToPackage = new Map<string, string>();\n  for (const pkg of manifests) {\n    for (const decl of pkg.declarations) {\n      tagNameToPackage.set(decl.tagName, pkg.packageName);\n    }\n  }\n\n  return decls.map((island) => {\n    const admission = evidence.admissionDecisions?.find(\n      (d) => d.tagName === island.tagName,\n    );\n    const ssr = admission?.renderPath === 'ssr+client';\n    const dsd = island.dsd !== false; // default: true\n    const renderPath: ManifestDecision['renderPath'] = ssr ? 'ssr+client' : 'client-only';\n\n    return {\n      tagName: island.tagName,\n      packageName: tagNameToPackage.get(island.tagName) || 'unknown',\n      ssr,\n      dsd,\n      hydrate: island.hydrate,\n      renderPath,\n      reason: admission?.reason,\n      source: 'package',\n    };\n  });\n}\n\n// ─── CEM Compatibility Report Builder (v0.18.0) ─────────────────\n\n/**\n * Build a CEM compatibility report from CEM classifications.\n *\n * Summarizes how the compatibility classifier classified each third-party\n * WC package component into a tier (ssr-capable, client-only, rejected,\n * experimental-dom). Written to dsd-report.json for CI assertion.\n *\n * Returns undefined when no CEM classifications exist.\n */\nexport function buildCemCompatibilityReport(\n  classifications?: CompatibilityClassification[],\n): CemCompatibilityReport | undefined {\n  if (!classifications?.length) return undefined;\n\n  const ssrCapableCount = classifications.filter((c) => c.tier === 'ssr-capable').length;\n  const clientOnlyCount = classifications.filter((c) => c.tier === 'client-only').length;\n  const rejectedCount = classifications.filter((c) => c.tier === 'rejected').length;\n  const experimentalDomCount = classifications.filter((c) => c.tier === 'experimental-dom').length;\n\n  // Order: rejected first (most critical), then ssr-capable, client-only, experimental-dom\n  const sortedClassifications = [...classifications].sort((a, b) => {\n    const tierOrder = {\n      rejected: 0,\n      'ssr-capable': 1,\n      'client-only': 2,\n      'experimental-dom': 3,\n    };\n    return (tierOrder[a.tier] ?? 99) - (tierOrder[b.tier] ?? 99);\n  });\n\n  const summaryParts: string[] = [];\n  if (ssrCapableCount > 0) summaryParts.push(`${ssrCapableCount} ssr-capable`);\n  if (clientOnlyCount > 0) summaryParts.push(`${clientOnlyCount} client-only`);\n  if (rejectedCount > 0) summaryParts.push(`${rejectedCount} rejected`);\n  if (experimentalDomCount > 0) summaryParts.push(`${experimentalDomCount} experimental-dom`);\n\n  return {\n    totalClassified: classifications.length,\n    ssrCapableCount,\n    clientOnlyCount,\n    rejectedCount,\n    experimentalDomCount,\n    classifications: sortedClassifications,\n    summary: summaryParts.length > 0\n      ? `CEM: ${summaryParts.join(', ')}`\n      : 'CEM: no components classified',\n  };\n}\n\n// ─── Report Assembly ────────────────────────────────────────────\n\n/**\n * Assemble the full dsd-report.json object from page diagnostics and evidence.\n */\nexport function assembleDsdReport(\n  pageDiagnostics: PageDiagnostic[],\n  evidence: SsgRenderEvidence,\n): DsdBuildReport {\n  const totalErrors = pageDiagnostics.reduce(\n    (sum, p) => sum + p.errors.length,\n    0,\n  );\n  const totalComponents = pageDiagnostics.reduce(\n    (sum, p) => sum + p.componentCount,\n    0,\n  );\n  const totalRenderTimeMs = pageDiagnostics.reduce(\n    (sum, p) => sum + p.renderTimeMs,\n    0,\n  );\n  const totalTemplateSize = pageDiagnostics.reduce(\n    (sum, p) => sum + p.hydrationHints.length,\n    0,\n  );\n  const errorComponentCount = pageDiagnostics.filter(\n    (p) => p.errors.length > 0,\n  ).length;\n  const maxNestingDepth = 0; // Determined from collector, not per-page\n  const interactiveCount = pageDiagnostics.reduce(\n    (sum, p) => sum + p.hydrationHints.filter((h) => h.layer === 'dsd-interactive').length,\n    0,\n  );\n  const pureIslandCount = pageDiagnostics.reduce(\n    (sum, p) => sum + p.hydrationHints.filter((h) => h.layer === 'pure-island').length,\n    0,\n  );\n  const totalHints = pageDiagnostics.reduce(\n    (sum, p) => sum + p.hydrationHints.length,\n    0,\n  );\n  const strategySummary = buildHydrationStrategySummary(evidence);\n\n  return {\n    reportVersion: '1.2.0',\n    timestamp: new Date().toISOString(),\n    totalPages: pageDiagnostics.length,\n    totalErrors,\n    renderErrors: pageDiagnostics.map((p) => ({\n      path: p.path,\n      errors: p.errors,\n      hydrationHints: p.hydrationHints,\n      componentCount: p.componentCount,\n      renderTimeMs: p.renderTimeMs,\n    })),\n    metricsSummary: {\n      totalComponents,\n      totalRenderTimeMs,\n      avgRenderTimeMs: totalComponents > 0\n        ? Math.round(totalRenderTimeMs / totalComponents * 100) / 100\n        : 0,\n      totalTemplateSize,\n      maxNestingDepth,\n      errorComponentCount,\n    },\n    hydrationHintSummary: {\n      totalHints,\n      interactiveCount,\n      pureIslandCount,\n    },\n    hydrationStrategySummary: strategySummary,\n    manifestDecisions: buildManifestDecisions(evidence),\n    admissionDecisions: evidence.admissionDecisions || [],\n    cemCompatibility: buildCemCompatibilityReport(\n      evidence.cemClassifications,\n    ),\n  };\n}\n\n/**\n * Write the DSD report to the output directory.\n */\nexport function writeDsdReport(\n  outputDir: string,\n  report: DsdBuildReport,\n): void {\n  const reportPath = join(outputDir, 'dsd-report.json');\n  writeFileSync(reportPath, writeJson(report), 'utf-8');\n  log.info(\n    `DSD report -> ${reportPath} (${report.totalPages} pages, ${report.totalErrors} errors)`,\n  );\n}\n"],"names":[],"mappings":"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"}

package/src/ssr-polyfills.d.ts

@@ -0,0 +1,15 @@
+/**
+ * SSR Polyfills for browser-only APIs.
+ *
+ * Polyfill 分层策略（ADR-0044）:
+ * - Entry code body (this module): CSSStyleSheet — needs `import { StyleSheet } from @openelement/core`
+ * - Output banner (build-ssg.ts): HTMLElement + customElements — no import, runs before module evaluation
+ *
+ * ADR-0044: SSR polyfill strategy — browser globals in Deno SSR runtime.
+ */ /**
+ * Generates the entry-code polyfill (CSSStyleSheet only).
+ *
+ * HTMLElement and customElements are in output.banner (build-ssg.ts)
+ * because they must execute BEFORE any ESM import is evaluated.
+ * CSSStyleSheet lives here because it needs `import { StyleSheet }`.
+ */ export declare function generateSsrPolyfillBanner(): string;

package/src/ssr-polyfills.js

@@ -0,0 +1,26 @@
+/**
+ * SSR Polyfills for browser-only APIs.
+ *
+ * Polyfill 分层策略（ADR-0044）:
+ * - Entry code body (this module): CSSStyleSheet — needs `import { StyleSheet } from @openelement/core`
+ * - Output banner (build-ssg.ts): HTMLElement + customElements — no import, runs before module evaluation
+ *
+ * ADR-0044: SSR polyfill strategy — browser globals in Deno SSR runtime.
+ */ /**
+ * Generates the entry-code polyfill (CSSStyleSheet only).
+ *
+ * HTMLElement and customElements are in output.banner (build-ssg.ts)
+ * because they must execute BEFORE any ESM import is evaluated.
+ * CSSStyleSheet lives here because it needs `import { StyleSheet }`.
+ */ export function generateSsrPolyfillBanner() {
+  return `\
+import { StyleSheet } from '@openelement/core';
+if (typeof globalThis.CSSStyleSheet === 'undefined') {
+  globalThis.CSSStyleSheet = class {
+    replaceSync(_css) {}
+    get cssRules() { return []; }
+  };
+}
+`;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9vcGVuZWxlbWVudC9vcGVuZWxlbWVudC9wYWNrYWdlcy9zc2cvc3JjL3Nzci1wb2x5ZmlsbHMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBTU1IgUG9seWZpbGxzIGZvciBicm93c2VyLW9ubHkgQVBJcy5cbiAqXG4gKiBQb2x5ZmlsbCDliIblsYLnrZbnlaXvvIhBRFItMDA0NO+8iTpcbiAqIC0gRW50cnkgY29kZSBib2R5ICh0aGlzIG1vZHVsZSk6IENTU1N0eWxlU2hlZXQg4oCUIG5lZWRzIGBpbXBvcnQgeyBTdHlsZVNoZWV0IH0gZnJvbSBAb3BlbmVsZW1lbnQvY29yZWBcbiAqIC0gT3V0cHV0IGJhbm5lciAoYnVpbGQtc3NnLnRzKTogSFRNTEVsZW1lbnQgKyBjdXN0b21FbGVtZW50cyDigJQgbm8gaW1wb3J0LCBydW5zIGJlZm9yZSBtb2R1bGUgZXZhbHVhdGlvblxuICpcbiAqIEFEUi0wMDQ0OiBTU1IgcG9seWZpbGwgc3RyYXRlZ3kg4oCUIGJyb3dzZXIgZ2xvYmFscyBpbiBEZW5vIFNTUiBydW50aW1lLlxuICovXG5cbi8qKlxuICogR2VuZXJhdGVzIHRoZSBlbnRyeS1jb2RlIHBvbHlmaWxsIChDU1NTdHlsZVNoZWV0IG9ubHkpLlxuICpcbiAqIEhUTUxFbGVtZW50IGFuZCBjdXN0b21FbGVtZW50cyBhcmUgaW4gb3V0cHV0LmJhbm5lciAoYnVpbGQtc3NnLnRzKVxuICogYmVjYXVzZSB0aGV5IG11c3QgZXhlY3V0ZSBCRUZPUkUgYW55IEVTTSBpbXBvcnQgaXMgZXZhbHVhdGVkLlxuICogQ1NTU3R5bGVTaGVldCBsaXZlcyBoZXJlIGJlY2F1c2UgaXQgbmVlZHMgYGltcG9ydCB7IFN0eWxlU2hlZXQgfWAuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZW5lcmF0ZVNzclBvbHlmaWxsQmFubmVyKCk6IHN0cmluZyB7XG4gIHJldHVybiBgXFxcbmltcG9ydCB7IFN0eWxlU2hlZXQgfSBmcm9tICdAb3BlbmVsZW1lbnQvY29yZSc7XG5pZiAodHlwZW9mIGdsb2JhbFRoaXMuQ1NTU3R5bGVTaGVldCA9PT0gJ3VuZGVmaW5lZCcpIHtcbiAgZ2xvYmFsVGhpcy5DU1NTdHlsZVNoZWV0ID0gY2xhc3Mge1xuICAgIHJlcGxhY2VTeW5jKF9jc3MpIHt9XG4gICAgZ2V0IGNzc1J1bGVzKCkgeyByZXR1cm4gW107IH1cbiAgfTtcbn1cbmA7XG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7O0NBUUMsR0FFRDs7Ozs7O0NBTUMsR0FDRCxPQUFPLFNBQVM7RUFDZCxPQUFPLENBQUM7Ozs7Ozs7O0FBUVYsQ0FBQztBQUNEIn0=