@emailmaker/emailmaker 1.1.32 → 1.1.37

package/webpack/index.js

@@ -1,5 +1,6 @@
 import path from "path";
 import fs from "fs";
+import { createRequire } from "module";
 //#region src/shared/stringCase.ts
 function toPascalCase(str) {
 	return `${str}`.toLowerCase().replace(/[-_]+/g, " ").replace(/[^\w\s]/g, "").replace(/\s+(.)(\w*)/g, (_m, a, b) => `${a.toUpperCase()}${b}`).replace(/\w/, (s) => s.toUpperCase());
@@ -18,6 +19,11 @@ function toPascalCase(str) {
 *   (`/product` -> `/product/`, resolved against the host `document.baseURI`).
 * - With `publicPath`: `http://host:3032` + `/product` -> `http://host:3032/product/`.
 */
+function normalizeHostBundlerPublicPath(publicPath) {
+	const value = String(publicPath ?? "").trim();
+	if (!value || value === "auto" || value === "automatic") return "";
+	return value;
+}
 function joinHostPublicPath(publicPath, outputFolder, defaultOutputFolder) {
 	const folder = outputFolder != null && outputFolder !== "" ? String(outputFolder) : defaultOutputFolder;
 	const base = String(publicPath || "").replace(/\/+$/, "");
@@ -60,12 +66,29 @@ function createInitFragment(environmentVariable, publicPath, startupPrefetchMode
 		`if (!window.${environmentVariable}.startupPrefetchMode) window.${environmentVariable}.startupPrefetchMode = "${startupPrefetchMode}";`
 	].join(" ");
 }
+function moduleSourceContainsFacadeSentinel(source) {
+	return typeof source === "string" && source.includes("@shared-runtime:init-complete");
+}
+/**
+* True when host bootstrap was already prepended (avoid double injection).
+*
+* Must match the host-plugin assignment shape from `createInitFragment` /
+* `createNormalizedPublicPathAssignment`, NOT a bare `window.__ns__.publicPath`
+* substring — publish diagnostics embed that substring inside string literals and
+* would otherwise false-positive and block all host injection.
+*/
+function moduleSourceHasHostPublicPathBootstrap(source, environmentVariable) {
+	if (typeof source !== "string" || !source) return false;
+	return source.includes(`if (!window.${environmentVariable}.publicPath) window.${environmentVariable}.publicPath =`);
+}
 //#endregion
 //#region src/shared/hostPackageEntryMatch.ts
 /**
 * Match main product entry modules for host bootstrap injection (Vite + Webpack).
 * Uses suffix matching so absolute node_modules ids ending with `{packagePath}/{appName}-esm.js`
 * match the same way as Webpack `renderModuleContent` (endsWith), not exact relative paths.
+* When path matching fails (alias, wrapper re-export), falls back to publish facade sentinel
+* in module source (`@shared-runtime:init-complete`).
 */
 function normalizeHostModulePath(value) {
 	return String(value || "").replace(/#.*$/s, "").replace(/\?.*$/s, "").replace(/\\/g, "/");
@@ -87,6 +110,50 @@ function shouldMatchProductPackageEntry(moduleId, packagePath, appName, optimize
 	}
 	return false;
 }
+function shouldPatchProductEntry(options) {
+	const { moduleId, source, packagePath, appName, optimizedDepFileName, environmentVariable } = options;
+	if (environmentVariable && moduleSourceHasHostPublicPathBootstrap(source, environmentVariable)) return false;
+	if (shouldMatchProductPackageEntry(moduleId, packagePath, appName, optimizedDepFileName)) return true;
+	return moduleSourceContainsFacadeSentinel(source);
+}
+//#endregion
+//#region src/shared/resolvePublishedPackage.ts
+/**
+* Resolve the on-disk root of the published main package (handles pnpm hoisting / symlinks).
+* Prefers `modulesPath/<packagePath>` under `cwd` when `package.json` exists there.
+*/
+function resolvePublishedPackageRoot(packagePath, modulesPath = "node_modules", cwd = process.cwd()) {
+	const modulesRoot = path.isAbsolute(modulesPath) ? modulesPath : path.join(cwd, modulesPath);
+	const localRoot = path.join(modulesRoot, ...packagePath.split("/"));
+	const localPackageJson = path.join(localRoot, "package.json");
+	if (fs.existsSync(localPackageJson)) return localRoot;
+	try {
+		const packageJsonPath = createRequire(path.join(cwd, "package.json")).resolve(`${packagePath}/package.json`);
+		return path.dirname(packageJsonPath);
+	} catch {
+		return localRoot;
+	}
+}
+var PublishedPackageNotFoundError = class extends Error {
+	constructor(packagePath, resolvedPath) {
+		super(`[host-plugin] Published package "${packagePath}" was not found at "${resolvedPath}". Install the product npm package or set \`modulesPath\` to the directory that contains it.`);
+		this.packagePath = packagePath;
+		this.resolvedPath = resolvedPath;
+		this.name = "PublishedPackageNotFoundError";
+	}
+};
+function assertPublishedPackageExists(packageRoot, packagePath) {
+	if (!fs.existsSync(packageRoot) || !fs.statSync(packageRoot).isDirectory()) throw new PublishedPackageNotFoundError(packagePath, packageRoot);
+}
+function assertCoreChunkInCompilationAssets(assetNames, appName, outputFolder) {
+	const folderPrefix = String(outputFolder || "").replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+	const corePattern = new RegExp(`(^|/)${appName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}-core\\.[^/]+\\.js$`);
+	if (!Array.from(assetNames).some((name) => {
+		const normalized = name.replace(/\\/g, "/");
+		if (folderPrefix && !(normalized === folderPrefix || normalized.startsWith(`${folderPrefix}/`))) return false;
+		return corePattern.test(normalized);
+	})) throw new Error(`[host-plugin] No "${appName}-core.*.js" asset was emitted under "${folderPrefix || "(output)"}" after copy. The published package may be incomplete or IGNORED_PATTERNS filtered the core chunk.`);
+}
 //#endregion
 //#region src/shared/branding.ts
 /**
@@ -134,12 +201,43 @@ function getWebpackModulePath(module) {
 	const name = typeof module.nameForCondition === "function" ? module.nameForCondition() : null;
 	return typeof name === "string" && name ? name : void 0;
 }
-function getModuleSourceCode(source) {
+function getConcatenatedInnerModules(module) {
+	const inner = module?.modules;
+	if (!inner) return [];
+	if (Array.isArray(inner)) return inner;
+	if (typeof inner[Symbol.iterator] === "function") return Array.from(inner);
+	return [];
+}
+function getWebpackModuleSource(source) {
+	if (typeof source === "string") return source;
 	if (source && typeof source === "object" && "source" in source && typeof source.source === "function") return source.source();
-	return String(source ?? "");
+	return "";
 }
-function shouldInjectRuntimeBootstrap(modulePath) {
-	return shouldMatchProductPackageEntry(modulePath || "", BUNDLER_DEFAULT_PACKAGE_NAME, BUNDLER_DEFAULT_APP_NAME);
+/**
+* With `optimization.concatenateModules` (scope hoisting) `renderModuleContent` fires once for
+* the `ConcatenatedModule`: its own `resource` is undefined and `nameForCondition`/`rootModule`
+* point at the host entry, not the product facade. We inspect the concatenated inner modules so
+* the publicPath bootstrap still reaches the facade (regression: enKod / Angular prod webpack).
+* Content sentinel fallback covers alias / wrapper paths where inner module paths do not match.
+*/
+function shouldInjectRuntimeBootstrap(module, source) {
+	const sourceCode = getWebpackModuleSource(source);
+	if (moduleSourceHasHostPublicPathBootstrap(sourceCode, ENVIRONMENT_VARIABLE)) return false;
+	const shared = {
+		packagePath: BUNDLER_DEFAULT_PACKAGE_NAME,
+		appName: BUNDLER_DEFAULT_APP_NAME,
+		environmentVariable: ENVIRONMENT_VARIABLE
+	};
+	if (shouldPatchProductEntry({
+		moduleId: getWebpackModulePath(module) || "",
+		source: sourceCode,
+		...shared
+	})) return true;
+	return getConcatenatedInnerModules(module).some((inner) => shouldPatchProductEntry({
+		moduleId: getWebpackModulePath(inner) || "",
+		source: void 0,
+		...shared
+	}));
 }
 /**
 * Webpack plugin for host applications.
@@ -184,7 +282,7 @@ var WebpackPlugin = class {
 	apply(compiler) {
 		const rawPub = compiler.options.output.publicPath;
 		const optionsPublicPath = typeof rawPub === "string" ? rawPub : "";
-		const initFragment = createInitFragment(ENVIRONMENT_VARIABLE, joinHostPublicPath(this._publicPath === void 0 ? optionsPublicPath : this._publicPath, this._outputFolder, DEFAULT_OUTPUT_FOLDER), this._startupPrefetchMode);
+		const initFragment = createInitFragment(ENVIRONMENT_VARIABLE, joinHostPublicPath(normalizeHostBundlerPublicPath(this._publicPath === void 0 ? optionsPublicPath : this._publicPath), this._outputFolder, DEFAULT_OUTPUT_FOLDER), this._startupPrefetchMode);
 		const webpack = compiler.webpack;
 		const javascript = webpack.javascript;
 		this._sources = webpack.sources;
@@ -194,18 +292,17 @@ var WebpackPlugin = class {
 				stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
 			}, async (_unusedAssets, cb) => {
 				try {
-					await this.copyFiles(compilation, path.join(this._modulesPath, BUNDLER_DEFAULT_PACKAGE_NAME), this._outputFolder);
+					const packageRoot = resolvePublishedPackageRoot(BUNDLER_DEFAULT_PACKAGE_NAME, this._modulesPath, compilation.compiler.context);
+					assertPublishedPackageExists(packageRoot, BUNDLER_DEFAULT_PACKAGE_NAME);
+					await this.copyFiles(compilation, packageRoot, this._outputFolder);
+					assertCoreChunkInCompilationAssets(compilation.getAssets().map((asset) => asset.name), BUNDLER_DEFAULT_APP_NAME, toAssetPath(this._outputFolder));
 					cb(null);
 				} catch (error) {
 					cb(error);
 				}
 			});
 			javascript.JavascriptModulesPlugin.getCompilationHooks(compilation).renderModuleContent.tap(PLUGIN_NAME, (source, module) => {
-				if (shouldInjectRuntimeBootstrap(getWebpackModulePath(module))) {
-					const sources = this._sources || compilation.compiler.webpack.sources;
-					const patched = `${initFragment}\n${getModuleSourceCode(source)}`;
-					return new sources.RawSource(patched);
-				}
+				if (shouldInjectRuntimeBootstrap(module, source)) return new (this._sources || compilation.compiler.webpack.sources).ConcatSource(`${initFragment}\n`, source);
 				return source;
 			});
 		});

package/static/core/e1095f09.js

@@ -1 +0,0 @@
-__emailmaker__.define(`static/core/e1095f09.js`,[`require`,`exports`,`module`,`static/core/354bf8a9.js`,`static/core/db185a82.js`],function(e,t,n){e("./354bf8a9.js"),t.default=e("./db185a82.js").t});