@emailmaker/emailmaker 1.0.107-dev.3 → 1.0.107-dev.4

package/vite/pluginDev/index.d.ts

@@ -1,22 +1,13 @@
-export interface PluginDevOptions {
-  /**
-   * Externals mode:
-   * - `'esm'`    — ESM imports from the runtime package (default)
-   * - `'globals'` — synchronous global variable access via window namespace
-   * - `false`    — no externals (modules bundled from runtime)
-   */
-  externals?: 'esm' | 'globals' | false;
+import { Plugin } from "vite";
 
-  /**
-   * Add resolve.alias for runtime modules (bare imports → runtime package paths).
-   * Does NOT alias ui-kit.
-   * Default:
-   * - true  for `externals: 'esm'` and `externals: false`
-   * - false for `externals: 'globals'`
-   */
+//#region node_modules/.cache/bundler-plugins-dts/shared/pluginDevOptions.d.ts
+type PluginDevExternalsMode = 'esm' | 'globals' | 'async-globals' | false;
+type PluginDevOptions = {
+  externals?: PluginDevExternalsMode | 'global';
   alias?: boolean;
-}
-
-export default function PluginDev(options?: PluginDevOptions): {
-  name: string;
 };
+//#endregion
+//#region node_modules/.cache/bundler-plugins-dts/vite/pluginDev/index.d.ts
+declare function PluginDev(options?: PluginDevOptions | true | null): Plugin;
+//#endregion
+export { PluginDev as default };

package/vite/pluginDev/index.js

@@ -1,207 +1,254 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let fs = require("fs");
+fs = __toESM(fs);
+let path = require("path");
+path = __toESM(path);
+let module$1 = require("module");
+//#region src/shared/runtimeManifest.ts
+var MANIFEST_FILE = "plugin-dev-manifest.json";
+function readJson(filePath) {
+	return JSON.parse(fs.default.readFileSync(filePath, "utf-8"));
+}
+function tryResolveFromPackage(_require, request) {
+	try {
+		return _require.resolve(request);
+	} catch {
+		return null;
+	}
+}
+function readRuntimeManifest(runtimePackage, pluginName) {
+	const _require = (0, module$1.createRequire)(path.default.resolve(process.cwd(), "package.json"));
+	const packageJsonPath = _require.resolve(`${runtimePackage}/package.json`);
+	const packageDir = path.default.dirname(packageJsonPath);
+	const manifestPath = tryResolveFromPackage(_require, `${runtimePackage}/plugin-dev-manifest.json`) || path.default.join(packageDir, "plugin-dev-manifest.json");
+	if (fs.default.existsSync(manifestPath)) {
+		const manifest = readJson(manifestPath);
+		console.log(`[${pluginName}] runtime manifest at ${manifestPath}`);
+		return manifest;
+	}
+	const runtimePkg = readJson(packageJsonPath);
+	if (!runtimePkg.runtimeModules || typeof runtimePkg.runtimeModules !== "object") throw new Error(`No "${MANIFEST_FILE}" and no legacy runtime metadata in ${runtimePackage}/package.json`);
+	console.warn(`[${pluginName}] ${MANIFEST_FILE} not found, falling back to legacy package.json metadata`);
+	return {
+		runtimeModules: runtimePkg.runtimeModules,
+		runtimeExports: runtimePkg.runtimeExports || {},
+		runtimeCoreModules: Array.isArray(runtimePkg.runtimeCoreModules) ? runtimePkg.runtimeCoreModules : [],
+		runtimeCoreExport: runtimePkg.runtimeCoreExport || "Core"
+	};
+}
+function createRuntimeEntryList(runtimeManifest) {
+	const runtimeModules = runtimeManifest.runtimeModules || {};
+	const runtimeExports = runtimeManifest.runtimeExports || {};
+	const runtimeCoreModules = Array.isArray(runtimeManifest.runtimeCoreModules) ? runtimeManifest.runtimeCoreModules : [];
+	return {
+		runtimeModules,
+		runtimeExports,
+		runtimeCoreModules,
+		runtimeCoreExport: runtimeManifest.runtimeCoreExport || "Core",
+		runtimeEntries: Object.entries(runtimeModules).map(([runtimeSubpath, originalName]) => ({
+			runtimeSubpath,
+			originalName,
+			exportName: runtimeExports[runtimeSubpath]
+		})),
+		runtimeCoreModuleSet: new Set(runtimeCoreModules)
+	};
+}
+//#endregion
+//#region src/shared/pluginDevOptions.ts
 /**
- * Vite plugin for extension development.
- *
- * Configures resolve.alias and rollup externals so that plugin authors
- * can write `import { useState } from 'react'` while the output
- * references the runtime package.
- *
- * Placeholders ($$…$$) are replaced by apply-version.ts at publish time.
- *
- * @example
- * // Production build — ESM externals + alias (default)
- * import PluginDev from '@emailmaker/emailmaker/vite/pluginDev';
- * plugins: [PluginDev()]
- *
- * @example
- * // Dev server — only alias, no externals (modules resolved from runtime)
- * plugins: [PluginDev({ externals: false })]
- *
- * @example
- * // Globals externals (IIFE/UMD output)
- * plugins: [PluginDev({ externals: 'globals' })]
- */
-
-const { readRuntimeManifest, createRuntimeEntryList } = require('../../shared/runtimeManifest');
-const { resolvePluginDevOptions } = require('../../shared/pluginDevOptions');
-
-// apply-version injects @emailmaker/runtime, __emailmaker__, @emailmaker/emailmaker, etc.
-// applyBundlerBuildDefaultReplacements then turns '$$BUILD_DEFAULT_*$$' into literals.
-const PACKAGE_PATH = "@emailmaker/emailmaker";
-const APP_NAME = "emailmaker";
-const RUNTIME_PACKAGE = '@emailmaker/runtime';
-const NAMESPACE = '__emailmaker__';
-
-const PLUGIN_NAME = `${APP_NAME}-pluginDev-vite`;
-const GLOBAL_PREFIX = '\0pluginDev-global:';
-
+* Normalizes shared `pluginDev` options for Vite and Webpack adapters.
+*/
+function resolvePluginDevOptions(options) {
+	let o = {};
+	if (options && options !== true) o = options;
+	const externals = o.externals === "global" ? "globals" : o.externals;
+	const defaultAlias = externals === void 0 || externals === "esm" || externals === false;
+	return {
+		externals: externals !== void 0 ? externals : "esm",
+		alias: o.alias !== void 0 ? o.alias : defaultAlias
+	};
+}
+//#endregion
+//#region src/shared/branding.ts
+var BUNDLER_DEFAULT_APP_NAME = "emailmaker";
+var BUNDLER_RUNTIME_PACKAGE = "@emailmaker/emailmaker/runtime";
+var BUNDLER_NAMESPACE = `__${BUNDLER_DEFAULT_APP_NAME}__`;
+//#endregion
+//#region src/vite/pluginDev/index.ts
+var PLUGIN_NAME = `${BUNDLER_DEFAULT_APP_NAME}-pluginDev-vite`;
+function extractBarePackageFromResolvedId(id) {
+	if (!id || typeof id !== "string") return null;
+	const normalized = id.replace(/\\/g, "/");
+	const idx = normalized.lastIndexOf("/node_modules/");
+	if (idx === -1) return null;
+	const parts = normalized.slice(idx + 14).split("/");
+	if (parts[0].startsWith("@")) {
+		if (parts.length < 2) return null;
+		return `${parts[0]}/${parts[1]}`;
+	}
+	return parts[0] || null;
+}
+function createGlobalPathResolver(globalMap) {
+	const keys = Object.keys(globalMap).sort((a, b) => b.length - a.length);
+	return function resolveGlobalPath(id) {
+		if (globalMap[id]) return globalMap[id];
+		for (let i = 0; i < keys.length; i += 1) {
+			const key = keys[i];
+			if (id === key || id.startsWith(`${key}/`)) return globalMap[key];
+		}
+		const bare = extractBarePackageFromResolvedId(id);
+		if (bare && globalMap[bare]) return globalMap[bare];
+		return null;
+	};
+}
+function chainRollupExternal(prevExternal, isOurExternal) {
+	return function external(id, importer, isResolved) {
+		if (isOurExternal(id)) return true;
+		if (prevExternal == null) return false;
+		if (typeof prevExternal === "function") {
+			const r = prevExternal(id, importer, isResolved);
+			return Boolean(r);
+		}
+		if (Array.isArray(prevExternal)) return prevExternal.includes(id);
+		if (prevExternal instanceof RegExp) return prevExternal.test(id);
+		return prevExternal === id;
+	};
+}
+function mergeRollupOutputWithGlobals(prevOutput, resolveGlobalPath, pluginName) {
+	function patchOne(out) {
+		const base = out && typeof out === "object" ? { ...out } : {};
+		const prevG = base.globals;
+		base.globals = function globals(id) {
+			const p = resolveGlobalPath(id);
+			if (p) return `window.${p}`;
+			if (typeof prevG === "function") return prevG(id);
+			if (prevG && typeof prevG === "object" && !Array.isArray(prevG)) return prevG[id];
+			throw new Error(`[${pluginName}] Missing global mapping for external id: ${id}`);
+		};
+		return base;
+	}
+	if (prevOutput == null) return patchOne({});
+	if (Array.isArray(prevOutput)) return prevOutput.map(patchOne);
+	return patchOne(prevOutput);
+}
+function mergeRollupOptionsForGlobals(userRollup, resolveGlobalPath, pluginName) {
+	const prev = userRollup || {};
+	const prevExternal = prev.external;
+	const isOurExternal = (id) => Boolean(resolveGlobalPath(id));
+	return {
+		...prev,
+		external: chainRollupExternal(prevExternal, isOurExternal),
+		output: mergeRollupOutputWithGlobals(prev.output, resolveGlobalPath, pluginName)
+	};
+}
 function printModeHints(opts) {
-  if (opts.externals === 'globals') {
-    console.warn(`[${PLUGIN_NAME}] globals mode is intended for the browser/script target. Make sure runtime globals are available before loading the plugin bundle.`);
-  }
-
-  if (opts.alias && opts.externals === 'globals') {
-    console.warn(`[${PLUGIN_NAME}] alias=true with globals mode is an advanced setup and is usually unnecessary.`);
-  }
+	if (opts.externals === "globals") console.warn(`[${PLUGIN_NAME}] globals mode is intended for the browser/script target. Make sure runtime globals are available before loading the plugin bundle.`);
+	if (opts.alias && opts.externals === "globals") console.warn(`[${PLUGIN_NAME}] alias=true with globals mode is an advanced setup and is usually unnecessary.`);
 }
-
-// =============================================================================
-// Plugin
-// =============================================================================
-
-/**
- * @param {Object} [options]
- * @param {'esm'|'globals'|false} [options.externals='esm']
- *   'esm'    — ESM imports from the runtime package
- *   'globals' — synchronous global variable access via window namespace
- *   false    — no externals (modules bundled from runtime)
- * @param {boolean} [options.alias]
- *   Default:
- *   - true  for 'esm' and false
- *   - false for 'globals'
- *   true  — resolve.alias rewrites bare imports to the runtime package
- *   false — no alias
- */
-module.exports = function PluginDev(options) {
-  const opts = resolvePluginDevOptions(options);
-
-  let runtimeModules, runtimeCoreModules, runtimeCoreExport, runtimeEntries, runtimeCoreModuleSet;
-  try {
-    ({
-      runtimeModules,
-      runtimeCoreModules,
-      runtimeCoreExport,
-      runtimeEntries,
-      runtimeCoreModuleSet,
-    } = createRuntimeEntryList(readRuntimeManifest(RUNTIME_PACKAGE, PLUGIN_NAME)));
-  } catch (e) {
-    throw new Error(
-      `[${PLUGIN_NAME}] ${RUNTIME_PACKAGE} not found.\n` +
-      `Make sure it is installed: npm install ${RUNTIME_PACKAGE}\n` +
-      (e.message || '')
-    );
-  }
-
-  const allOriginalNames = Object.values(runtimeModules);
-
-  // --- alias entries (runtime modules only, NOT ui-kit) ---
-  const aliasEntries = [];
-  if (opts.alias || runtimeCoreModules.length > 0) {
-    for (const originalName of allOriginalNames) {
-      if (!opts.alias && !runtimeCoreModuleSet.has(originalName)) {
-        continue;
-      }
-      aliasEntries.push({
-        find: originalName,
-        replacement: `${RUNTIME_PACKAGE}/${originalName}`,
-      });
-    }
-  }
-
-  // --- global mode virtual module map ---
-  const isGlobalMode = opts.externals === 'globals';
-  const isEsmMode = opts.externals === 'esm';
-  const globalMap = {};
-  if (isGlobalMode) {
-    if (runtimeCoreModules.length > 0) {
-      globalMap[`${RUNTIME_PACKAGE}/core`] = `${NAMESPACE}.modules.${runtimeCoreExport}`;
-    }
-
-    for (const { runtimeSubpath, originalName, exportName } of runtimeEntries) {
-      if (!originalName || !exportName) {
-        continue;
-      }
-      if (runtimeCoreModuleSet.has(originalName)) {
-        continue;
-      }
-
-      const globalPath = `${NAMESPACE}.modules.${exportName}`;
-      globalMap[originalName] = globalPath;
-      globalMap[`${RUNTIME_PACKAGE}/${runtimeSubpath}`] = globalPath;
-    }
-  }
-
-  // --- logging ---
-  console.log(`[${PLUGIN_NAME}] externals: ${opts.externals || 'disabled'}, alias: ${opts.alias}`);
-  printModeHints(opts);
-  if (opts.externals) {
-    console.log(`[${PLUGIN_NAME}] ${allOriginalNames.length} runtime externals`);
-  }
-
-  // --- Vite plugin object ---
-  return {
-    name: PLUGIN_NAME,
-    enforce: 'pre',
-
-    config() {
-      const config = {};
-      const runtimeAliasedNames = allOriginalNames.map(n => `${RUNTIME_PACKAGE}/${n}`);
-
-      // resolve.alias
-      if (aliasEntries.length > 0) {
-        config.resolve = { alias: aliasEntries };
-      }
-
-      // Make Vite use the same JSX source that PluginDev aliases to runtime.
-      config.esbuild = {
-        jsx: 'automatic',
-        ...(opts.alias ? { jsxImportSource: `${RUNTIME_PACKAGE}/react` } : {}),
-        // Runtime is always built in production mode, so dev hosts must
-        // compile JSX to `jsx/jsxs` instead of `jsxDEV`.
-        jsxDev: false,
-      };
-
-      // Prevent optimizeDeps from prebundling a different React/jsx runtime.
-      config.optimizeDeps = {
-        exclude: [
-          ...allOriginalNames,
-          ...runtimeAliasedNames,
-        ],
-      };
-
-      return config;
-    },
-
-    // Global mode: redirect imports to virtual modules
-    resolveId(source) {
-      if (isGlobalMode && globalMap[source]) {
-        return GLOBAL_PREFIX + source;
-      }
-
-      if (isEsmMode) {
-        if (source === `${RUNTIME_PACKAGE}/core`) {
-          return { id: source, external: true };
-        }
-
-        if (source.startsWith(`${RUNTIME_PACKAGE}/`)) {
-          const runtimeSubpath = source.slice(`${RUNTIME_PACKAGE}/`.length);
-          if (runtimeCoreModuleSet.has(runtimeSubpath)) {
-            return null;
-          }
-          return { id: source, external: true };
-        }
-
-        if (runtimeModules[source] !== undefined) {
-          return { id: `${RUNTIME_PACKAGE}/${source}`, external: true };
-        }
-      }
-
-      return null;
-    },
-
-    load(id) {
-      if (!id.startsWith(GLOBAL_PREFIX)) return null;
-      const request = id.slice(GLOBAL_PREFIX.length);
-      const globalPath = globalMap[request];
-      if (!globalPath) return null;
-
-      return {
-        code: [
-          `// Virtual module for "${request}"`,
-          `const __m = window.${globalPath};`,
-          'export default __m;',
-        ].join('\n'),
-        syntheticNamedExports: true,
-      };
-    },
-  };
-};
+function PluginDev(options) {
+	const opts = resolvePluginDevOptions(options);
+	let runtimeModules;
+	let runtimeCoreModules;
+	let runtimeCoreExport;
+	let runtimeEntries;
+	let runtimeCoreModuleSet;
+	try {
+		({runtimeModules, runtimeCoreModules, runtimeCoreExport, runtimeEntries, runtimeCoreModuleSet} = createRuntimeEntryList(readRuntimeManifest(BUNDLER_RUNTIME_PACKAGE, PLUGIN_NAME)));
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		throw new Error(`[${PLUGIN_NAME}] ${BUNDLER_RUNTIME_PACKAGE} not found.\nMake sure it is installed: npm install ${BUNDLER_RUNTIME_PACKAGE}\n` + msg);
+	}
+	const allOriginalNames = Object.values(runtimeModules);
+	const aliasEntries = [];
+	if (opts.alias || runtimeCoreModules.length > 0) for (const originalName of allOriginalNames) {
+		if (!opts.alias && !runtimeCoreModuleSet.has(originalName)) continue;
+		aliasEntries.push({
+			find: originalName,
+			replacement: `${BUNDLER_RUNTIME_PACKAGE}/${originalName}`
+		});
+	}
+	const isGlobalMode = opts.externals === "globals";
+	const isEsmMode = opts.externals === "esm";
+	const globalMap = {};
+	if (isGlobalMode) {
+		if (runtimeCoreModules.length > 0) globalMap[`${BUNDLER_RUNTIME_PACKAGE}/core`] = `${BUNDLER_NAMESPACE}.modules.${runtimeCoreExport}`;
+		for (const { runtimeSubpath, originalName, exportName } of runtimeEntries) {
+			if (!originalName) continue;
+			if (runtimeCoreModuleSet.has(originalName)) {
+				const coreGlobalPath = `${BUNDLER_NAMESPACE}.modules.${runtimeCoreExport}`;
+				globalMap[originalName] = coreGlobalPath;
+				globalMap[`${BUNDLER_RUNTIME_PACKAGE}/${runtimeSubpath}`] = coreGlobalPath;
+				continue;
+			}
+			if (!exportName) continue;
+			const globalPath = `${BUNDLER_NAMESPACE}.modules.${exportName}`;
+			globalMap[originalName] = globalPath;
+			globalMap[`${BUNDLER_RUNTIME_PACKAGE}/${runtimeSubpath}`] = globalPath;
+		}
+	}
+	const resolveGlobalPath = isGlobalMode ? createGlobalPathResolver(globalMap) : null;
+	console.log(`[${PLUGIN_NAME}] externals: ${opts.externals || "disabled"}, alias: ${opts.alias}`);
+	printModeHints(opts);
+	if (opts.externals) console.log(`[${PLUGIN_NAME}] ${allOriginalNames.length} runtime externals`);
+	return {
+		name: PLUGIN_NAME,
+		enforce: "pre",
+		config(userConfig) {
+			const config = {};
+			const runtimeAliasedNames = allOriginalNames.map((n) => `${BUNDLER_RUNTIME_PACKAGE}/${n}`);
+			if (aliasEntries.length > 0) config.resolve = { alias: aliasEntries };
+			config.esbuild = {
+				jsx: "automatic",
+				...opts.alias ? { jsxImportSource: `${BUNDLER_RUNTIME_PACKAGE}/react` } : {},
+				jsxDev: false
+			};
+			config.optimizeDeps = { exclude: [...allOriginalNames, ...runtimeAliasedNames] };
+			if (isGlobalMode && resolveGlobalPath && Object.keys(globalMap).length > 0) config.build = { rollupOptions: mergeRollupOptionsForGlobals(userConfig && userConfig.build && userConfig.build.rollupOptions, resolveGlobalPath, PLUGIN_NAME) };
+			return config;
+		},
+		resolveId(source) {
+			if (isEsmMode) {
+				if (source === `@emailmaker/emailmaker/runtime/core`) return {
+					id: source,
+					external: true
+				};
+				if (source.startsWith(`@emailmaker/emailmaker/runtime/`)) {
+					const runtimeSubpath = source.slice(`${BUNDLER_RUNTIME_PACKAGE}/`.length);
+					if (runtimeCoreModuleSet.has(runtimeSubpath)) return null;
+					return {
+						id: source,
+						external: true
+					};
+				}
+				if (runtimeModules[source] !== void 0) return {
+					id: `${BUNDLER_RUNTIME_PACKAGE}/${source}`,
+					external: true
+				};
+			}
+			return null;
+		}
+	};
+}
+//#endregion
+module.exports = PluginDev;

package/webpack/index.d.ts

@@ -1,13 +1,32 @@
-import { Compiler, WebpackPluginInstance } from 'webpack';
+import { Compilation, Compiler } from "webpack";
 
-export type WebpackPluginOptions = {
+//#region node_modules/.cache/bundler-plugins-dts/webpack/index.d.ts
+type WebpackPluginOptions = {
   outputFolder?: string;
   modulesPath?: string;
   publicPath?: string;
   startupPrefetchMode?: 'eager' | 'idle' | 'manual' | 'off';
 };
-
-export default class WebpackPlugin implements WebpackPluginInstance {
+/**
+ * Webpack plugin for host applications.
+ * Copies static assets (images, iframe, fonts, monaco workers) to the build output
+ * and injects publicPath into the entry module so the editor can locate them at runtime.
+ * The thin facade entry is still handled by the consumer bundler, while
+ * browser-loaded core assets are copied to the host output and served from publicPath.
+ *
+ * For plugin development (externals + alias), use a separate plugin
+ * from the `webpack/pluginDev` subpath.
+ */
+declare class WebpackPlugin {
+  _outputFolder: string;
+  _modulesPath: string;
+  _publicPath: string | undefined;
+  _startupPrefetchMode: string;
+  _sources: Compiler['webpack']['sources'] | null;
   constructor(options?: WebpackPluginOptions);
-  apply: (compiler: Compiler) => void;
+  addAsset(compilation: Compilation, sourcePath: string, destPath: string): Promise<void>;
+  copyFiles(compilation: Compilation, source: string, destination: string): Promise<void>;
+  apply(compiler: Compiler): void;
 }
+//#endregion
+export { WebpackPluginOptions, WebpackPlugin as default };