@salesforce/storefront-next-dev 1.3.0 → 1.3.1

package/README.md

@@ -57,9 +57,9 @@ export default defineConfig({
 });
 ```
 
-#### Page Designer critical-region preload manifest
+#### Page Designer regional preload manifest
 
-Set `staticRegistry.preloadManifest` to `true` when the application renders page-level Page Designer regions with `<Region critical>`. During a production application build, the plugin correlates statically discovered `@Component` modules with the finalized Vite client manifest, embeds a compact resource manifest in the server bundle, and enables Vite's standard client manifest. Development builds expose an empty preload manifest; normal registry loading still works.
+Set `staticRegistry.preloadManifest` to `true` when the application emits resource hints for server-rendered Page Designer regions. During a production application build, the plugin correlates statically discovered `@Component` modules with the finalized Vite client manifest, embeds a compact resource manifest in the server bundle, and enables Vite's standard client manifest. Development builds expose an empty preload manifest; normal registry loading still works.
 
 The preload manifest is disabled by default for SDK consumers. It can also be configured explicitly:
 
@@ -74,16 +74,12 @@ storefrontNextPlugin({
             path: 'page-designer-preload-manifest.json',
             // Fail the build unless these type IDs were discovered and mapped.
             requiredTypeIds: ['hero'],
-            compression: {
-                brotli: { quality: 9 }, // integer from 0 through 11
-                gzip: { level: 6 },     // integer from 0 through 9
-            },
         },
     },
 });
 ```
 
-Defaults are `page-designer-preload-manifest.json`, Brotli quality `9`, and Gzip level `6`. Duplicate Page Designer `typeId` values fail manifest generation. A discovered component that cannot be correlated to a client chunk produces a build warning, or a build error when its ID appears in `requiredTypeIds`.
+The default path is `page-designer-preload-manifest.json`. Duplicate Page Designer `typeId` values fail manifest generation. A discovered component that cannot be correlated to a client chunk produces a build warning, or a build error when its ID appears in `requiredTypeIds`.
 
 ### React Router Preset
 

package/dist/index.d.ts

@@ -3,18 +3,9 @@ import { Plugin, ResolvedConfig } from "vite";
 
 //#region src/plugins/pageDesignerPreloadManifest.d.ts
 
-interface PageDesignerPreloadCompressionConfig {
-  brotli?: {
-    quality?: number;
-  };
-  gzip?: {
-    level?: number;
-  };
-}
 interface PageDesignerPreloadManifestConfig {
   path?: string;
   requiredTypeIds?: string[];
-  compression?: PageDesignerPreloadCompressionConfig;
 }
 //#endregion
 //#region src/plugins/staticRegistry.d.ts

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/plugins/pageDesignerPreloadManifest.ts","../src/plugins/staticRegistry.ts","../src/plugins/eventInstrumentationValidator.ts","../src/storefront-next-targets.ts","../src/plugins/transformTargets.ts","../src/plugins/uiTargetDevMode.ts","../src/plugins/hybridProxy.ts","../src/plugins/ecdnMatcher.ts"],"sourcesContent":[],"mappings":";;;;;UAiCiB,oCAAA;EIJD,MAAA,CAAA,EAAA;;;;ICHC,KAAA,CAAA,EAAA,MAAA;EA4BD,CAAA;;ULhBC,iCAAA;;EMuBA,eAAA,CAAA,EAAA,MAAA,EAAA;EAyZD,WAAA,CAAA,EN7aE,oCM6ayB;;;;;;ACxU3C;;UN3EiB,0BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;8BA+Be;;;;;;AE3DhC;AAkEA;UD/EiB,mCAAA;;;AEGjB;;;;ACHA;AA4BA;;;;ACOA;AAyZA;;;;;;;AH7WA;;;UAlEiB,2BAAA;ECVD;;;;ACHhB;AA4BA;;;;ACOA;AAyZA;;;;ACxUA;;;;;;;;;;;;;;;;;;mBJrEqB;;;;;;;;;kCAUe;;;;;;;;;;;;;;;;;;;;;iBAsBpB,qBAAA,UAA8B,8BAAmC;;;iBC5EjE,gCAAA,CAAA;;;EJIC,cAAA,CAAA,MAAA,EIMc,cJNd,CAAA,EAAoC,IAAA;EAKpC,UAAA,EAAA,EAAA,IAAA;;;;EC6BA,CAAA,GAAA,IAAA;;;;;AE5BjB;AAkEA;;;;AC5EA;;;UCHiB,qBAAA;EAAA;AA4BjB;;;;ACOA;AAyZA;;;;ACxUA;YFtGc;;;;;;;;;;;;;iBAcE,qBAAA,WAAgC,wBAAwB;;;;UCOvD,wBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyZD,iBAAA,UAA2B,2BAA2B;;;;;;;;;;;;;;;;;;;;;;iBCxUtD,iBAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/plugins/pageDesignerPreloadManifest.ts","../src/plugins/staticRegistry.ts","../src/plugins/eventInstrumentationValidator.ts","../src/storefront-next-targets.ts","../src/plugins/transformTargets.ts","../src/plugins/uiTargetDevMode.ts","../src/plugins/hybridProxy.ts","../src/plugins/ecdnMatcher.ts"],"sourcesContent":[],"mappings":";;;;;AI6BgB,UJGC,iCAAA,CIOc;;;;;;;AGuG/B;;;UN3EiB,0BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;8BA+Be;;;;;AE3DhC;AAkEA;;UD/EiB,mCAAA;;AEGjB;;;;ECHiB;AA4BjB;;;;ECOiB;AAyZjB;;;;ACxUA;;;;;;;AHjHgB,UDUC,2BAAA,CCV+B;;;;ACHhD;AA4BA;;;;ACOA;AAyZA;;;;ACxUA;;;;;;;;;;;;;;;;;;;mBJrEqB;;;;;;;;;kCAUe;;;;;;;;;;;;;;;;;;;;;iBAsBpB,qBAAA,UAA8B,8BAAmC;;;iBC5EjE,gCAAA,CAAA;;;EJGC,cAAA,CAAA,MAAA,EIOc,cJPmB,CAAA,EAAA,IAAA;;;;ICmCjC,GAAA,EAAA,IAAA;;;;;AE5BjB;AAkEA;;;;AC5EA;;;;ACHiB,UAAA,qBAAA,CAcH;EAcE;;;;ECOC;AAyZjB;;;;ACxUA;;YFtGc;;;;;;;;;;;;;iBAcE,qBAAA,WAAgC,wBAAwB;;;;UCOvD,wBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyZD,iBAAA,UAA2B,2BAA2B;;;;;;;;;;;;;;;;;;;;;;iBCxUtD,iBAAA"}

package/dist/index.js

@@ -12,7 +12,6 @@ import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "
 import { glob } from "glob";
 import { Node, Project, ts } from "ts-morph";
 import { spawnSync } from "child_process";
-import { brotliCompressSync, constants, gzipSync } from "node:zlib";
 import fs$1, { existsSync as existsSync$1, readFileSync as readFileSync$1 } from "node:fs";
 import { deadCodeElimination, findReferencedIdentifiers } from "babel-dead-code-elimination";
 import httpProxy from "http-proxy";
@@ -893,26 +892,15 @@ function assertViteManifestStructure(value) {
 		if (!("file" in record) || typeof record.file !== "string" || record.file.length === 0) throw new Error(`Invalid standard Vite manifest: record "${key}" must have a non-empty string "file"`);
 	}
 }
-function integerInRange(value, path$2, min, max, fallback) {
-	if (value === void 0) return fallback;
-	if (!Number.isInteger(value) || value < min || value > max) throw new Error(`${path$2} must be an integer between ${min} and ${max}`);
-	return value;
-}
 function normalizePageDesignerPreloadManifestConfig(config) {
 	const options = typeof config === "object" ? config : {};
 	return {
 		path: options.path ?? "page-designer-preload-manifest.json",
-		requiredTypeIds: [...new Set(options.requiredTypeIds ?? [])].sort(),
-		compression: {
-			brotli: { quality: integerInRange(options.compression?.brotli?.quality, "preloadManifest.compression.brotli.quality", 0, 11, 9) },
-			gzip: { level: integerInRange(options.compression?.gzip?.level, "preloadManifest.compression.gzip.level", 0, 9, 6) }
-		}
+		requiredTypeIds: [...new Set(options.requiredTypeIds ?? [])].sort()
 	};
 }
-function createEmptyPageDesignerPreloadManifest(config) {
+function createEmptyPageDesignerPreloadManifest() {
 	return {
-		version: 1,
-		compression: config.compression,
 		resources: [],
 		components: {}
 	};
@@ -924,20 +912,11 @@ function normalizeSourceId(projectRoot, id) {
 	if (withoutQuery.startsWith(`${normalizedRoot}/`)) return withoutQuery.slice(normalizedRoot.length + 1);
 	return withoutQuery.startsWith("/") ? relative(projectRoot, withoutQuery).replace(/\\/g, "/") : withoutQuery;
 }
-function outputBytes(output) {
-	if (output.type === "chunk") return Buffer.from(output.code);
-	return Buffer.isBuffer(output.source) ? output.source : Buffer.from(output.source);
-}
-function describeResource(file, kind, bundle, config) {
-	const output = bundle[file];
-	if (!output) throw new Error(`Vite manifest references missing emitted resource "${file}"`);
-	const bytes = outputBytes(output);
+function describeResource(file, kind, bundle) {
+	if (!bundle[file]) throw new Error(`Vite manifest references missing emitted resource "${file}"`);
 	return {
 		file,
-		kind,
-		bytes: bytes.byteLength,
-		estimatedBrotliBytes: brotliCompressSync(bytes, { params: { [constants.BROTLI_PARAM_QUALITY]: config.compression.brotli.quality } }).byteLength,
-		estimatedGzipBytes: gzipSync(bytes, { level: config.compression.gzip.level }).byteLength
+		kind
 	};
 }
 function assertUniqueTypeIds(components) {
@@ -1004,9 +983,7 @@ function buildPageDesignerPreloadManifest(components, viteManifest, bundle, proj
 	const resourceIndices = Object.fromEntries(resourceFiles.map((file, index) => [file, index]));
 	const toIndices = (files) => files.map((file) => resourceIndices[file]);
 	return {
-		version: 1,
-		compression: config.compression,
-		resources: resourceFiles.map((file) => describeResource(file, resourceKinds.get(file), bundle, config)),
+		resources: resourceFiles.map((file) => describeResource(file, resourceKinds.get(file), bundle)),
 		components: Object.fromEntries(Object.entries(componentFiles).map(([typeId, files]) => [typeId, {
 			...files.styles ? { styles: toIndices(files.styles) } : {},
 			...files.entries ? { entries: toIndices(files.entries) } : {},
@@ -1027,9 +1004,9 @@ function parseViteManifestAsset(bundle) {
 	return parsed;
 }
 function validateEmbeddedPageDesignerPreloadManifest(value) {
-	if (!value || typeof value !== "object" || value.version !== 1) throw new Error("Page Designer preload manifest is missing, malformed, or uses an unsupported version");
+	if (!value || typeof value !== "object") throw new Error("Page Designer preload manifest is missing or malformed");
 	const candidate = value;
-	if (!candidate.compression || !Array.isArray(candidate.resources) || !candidate.components || typeof candidate.components !== "object") throw new Error("Page Designer preload manifest is incomplete");
+	if (!Array.isArray(candidate.resources) || !candidate.components || typeof candidate.components !== "object") throw new Error("Page Designer preload manifest is incomplete");
 }
 
 //#endregion
@@ -1160,25 +1137,22 @@ function generateRegistryCode(components, registryIdentifier = "registry") {
 export function initializeRegistry(targetRegistry = ${registryIdentifier}): void {
     // No components found with @Component decorators
 }
-
-/** Load selected component modules and register their concrete exports before SSR. */
-export async function loadAndRegisterRegistryComponents(
-    typeIds: Iterable<string>,
-    targetRegistry = ${registryIdentifier}
-): Promise<void> {
-    await Promise.all([...new Set(typeIds)].map((id) => targetRegistry.loadAndRegister(id)));
-}
 `;
-	const registrations = sorted.map(({ id, relativePath, hasLoader, hasClientLoader, hasFallback }) => {
+	const importers = sorted.map(({ relativePath }) => `    () => import('${relativePath}'),`).join("\n");
+	const registrations = sorted.map(({ id, hasLoader, hasClientLoader, hasFallback }, index) => {
 		if (hasLoader || hasClientLoader || hasFallback) {
 			const metadata = [];
 			if (hasLoader) metadata.push(`loader: 'loader'`);
 			if (hasClientLoader) metadata.push(`clientLoader: 'clientLoader'`);
 			if (hasFallback) metadata.push(`fallback: 'fallback'`);
-			return `    targetRegistry.registerImporter('${id}', () => import('${relativePath}'), { ${metadata.join(", ")} });`;
-		} else return `    targetRegistry.registerImporter('${id}', () => import('${relativePath}'));`;
+			return `    targetRegistry.registerImporter('${id}', staticRegistryImporters[${index}], { ${metadata.join(", ")} });`;
+		} else return `    targetRegistry.registerImporter('${id}', staticRegistryImporters[${index}]);`;
 	}).join("\n");
 	return `
+const staticRegistryImporters = [
+${importers}
+] as const;
+
 /**
  * Initialize the static component registry.
  * This function is auto-generated by the staticRegistry Vite plugin.
@@ -1190,18 +1164,6 @@ export async function loadAndRegisterRegistryComponents(
 export function initializeRegistry(targetRegistry = ${registryIdentifier}): void {
 ${registrations}
 }
-
-/**
- * Load selected component modules and register their concrete exports before SSR.
- * This keeps the component boundary out of the initial Suspense shell while
- * preserving nested data-loading Suspense boundaries and their fallbacks.
- */
-export async function loadAndRegisterRegistryComponents(
-    typeIds: Iterable<string>,
-    targetRegistry = ${registryIdentifier}
-): Promise<void> {
-    await Promise.all([...new Set(typeIds)].map((id) => targetRegistry.loadAndRegister(id)));
-}
 `;
 }
 /**
@@ -1312,8 +1274,8 @@ const staticRegistryPlugin = (config = {}) => {
 		},
 		load(id) {
 			if (!normalizedPreloadConfig || id !== RESOLVED_PAGE_DESIGNER_PRELOAD_MANIFEST_ID) return;
-			if (!isProductionBuild) return `export default ${JSON.stringify(createEmptyPageDesignerPreloadManifest(normalizedPreloadConfig))};`;
-			if (this.environment?.name === "client") return `export default ${JSON.stringify(createEmptyPageDesignerPreloadManifest(normalizedPreloadConfig))};`;
+			if (!isProductionBuild) return `export default ${JSON.stringify(createEmptyPageDesignerPreloadManifest())};`;
+			if (this.environment?.name === "client") return `export default ${JSON.stringify(createEmptyPageDesignerPreloadManifest())};`;
 			validateEmbeddedPageDesignerPreloadManifest(embeddedManifest);
 			return `export default ${JSON.stringify(embeddedManifest)};`;
 		},