@powerhousedao/builder-tools 6.0.0-dev.23 → 6.0.0-dev.231

package/dist/index.mjs

@@ -0,0 +1,627 @@
+import { createRequire } from "node:module";
+import { exec, execSync } from "node:child_process";
+import fs, { existsSync, readFileSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import path, { join, resolve } from "node:path";
+import { cwd } from "node:process";
+import { loadConnectEnv, setConnectEnv } from "@powerhousedao/shared/connect";
+import { getConfig } from "@powerhousedao/config/node";
+import tailwind from "@tailwindcss/vite";
+import react from "@vitejs/plugin-react";
+import { createLogger, esmExternalRequirePlugin, loadEnv } from "vite";
+import { createHtmlPlugin } from "vite-plugin-html";
+//#region connect-utils/constants.ts
+const EXTERNAL_PACKAGES_IMPORT = "PH:EXTERNAL_PACKAGES";
+const IMPORT_SCRIPT_FILE = "external-packages.js";
+const LOCAL_PACKAGE_ID = "ph:local-package";
+const PH_DIR_NAME = ".ph";
+//#endregion
+//#region connect-utils/helpers.ts
+const DEFAULT_CONNECT_OUTDIR = ".ph/connect-build/dist/";
+function commonConnectOptionsToEnv(options) {
+	const { base, configFile, defaultDrivesUrl, drivesPreserveStrategy, disableLocalPackage } = options;
+	if (base) setConnectEnv({ PH_CONNECT_BASE_PATH: base });
+	if (configFile) setConnectEnv({ PH_CONFIG_PATH: configFile });
+	if (defaultDrivesUrl) setConnectEnv({ PH_CONNECT_DEFAULT_DRIVES_URL: defaultDrivesUrl.join(",") });
+	if (drivesPreserveStrategy) setConnectEnv({ PH_CONNECT_DRIVES_PRESERVE_STRATEGY: drivesPreserveStrategy });
+	if (disableLocalPackage) setConnectEnv({ PH_DISABLE_LOCAL_PACKAGE: true });
+}
+function resolveViteConfigPath(options) {
+	const { projectRoot = cwd(), viteConfigFile } = options;
+	return viteConfigFile || join(projectRoot, "vite.config.ts");
+}
+function resolvePackage(packageName, root = process.cwd()) {
+	return createRequire(root).resolve(packageName, { paths: [root] });
+}
+function resolveConnectPackageJson(root = process.cwd()) {
+	try {
+		const connectPackageJsonPath = resolvePackage("@powerhousedao/connect/package.json", root);
+		const fileContents = fs.readFileSync(connectPackageJsonPath, "utf-8");
+		return JSON.parse(fileContents);
+	} catch (error) {
+		console.error(`Error reading Connect package.json:`, error);
+		return null;
+	}
+}
+/**
+* Finds the dist dir of Connect on the local machine
+*/
+function resolveConnectBundle(root = process.cwd()) {
+	const connectIndexPath = resolvePackage("@powerhousedao/connect", root);
+	return join(connectIndexPath.substring(0, connectIndexPath.indexOf("connect") + 7), "dist/");
+}
+function resolveConnectPublicDir(root = process.cwd()) {
+	const connectIconPath = resolvePackage("@powerhousedao/connect/public/icon.ico", root);
+	return path.join(connectIconPath, "../");
+}
+/**
+* Copies the Connect dist dir to the target path
+*/
+function copyConnect(sourcePath, targetPath) {
+	try {
+		fs.rmSync(targetPath, {
+			recursive: true,
+			force: true
+		});
+		fs.cpSync(sourcePath, targetPath, { recursive: true });
+	} catch (error) {
+		console.error(`❌ Error copying ${sourcePath} to ${targetPath}:`, error);
+	}
+}
+/**
+* Backs up the index.html file
+*
+* Needed when running the Connect Studio dev server on Windows
+*/
+function backupIndexHtml(appPath, restore = false) {
+	const filePath = join(appPath, "index.html");
+	const backupPath = join(appPath, "index.html.bak");
+	const paths = restore ? [backupPath, filePath] : [filePath, backupPath];
+	if (fs.existsSync(paths[0])) fs.copyFileSync(paths[0], paths[1]);
+}
+function removeBase64EnvValues(appPath) {
+	backupIndexHtml(appPath);
+	const filePath = join(appPath, "index.html");
+	fs.readFile(filePath, "utf-8", (err, data) => {
+		if (err) {
+			console.error("Error reading file:", err);
+			return;
+		}
+		const modifiedData = data.replace(/"LOCAL_DOCUMENT_MODELS":\s*".*?",/, `"LOCAL_DOCUMENT_MODELS": "",`).replace(/"LOCAL_DOCUMENT_EDITORS":\s*".*?"/, `"LOCAL_DOCUMENT_EDITORS": ""`);
+		console.log("Modified data:", modifiedData);
+		fs.writeFile(filePath, modifiedData, "utf-8", (err) => {
+			if (err) {
+				console.error("Error writing file:", err);
+				return;
+			}
+		});
+	});
+}
+function readJsonFile(filePath) {
+	try {
+		const absolutePath = resolve(filePath);
+		const fileContents = fs.readFileSync(absolutePath, "utf-8");
+		return JSON.parse(fileContents);
+	} catch (error) {
+		console.error(`Error reading file: ${filePath}`);
+		return null;
+	}
+}
+/**
+* Takes a list of Powerhouse project packages and optionally local Powerhouse packages and outputs a js file which exports those packages for use in Connect Studio.
+*/
+function makeImportScriptFromPackages(args) {
+	const { packages, localJsPath, localCssPath, importStyles = true } = args;
+	const imports = [];
+	const moduleNames = [];
+	let counter = 0;
+	for (const packageName of packages) {
+		const moduleName = `module${counter}`;
+		moduleNames.push(moduleName);
+		imports.push(`import * as ${moduleName} from '${packageName}';`);
+		if (importStyles) imports.push(`import '${packageName}/style.css';`);
+		counter++;
+	}
+	const exports = moduleNames.map((name, index) => `{
+      id: "${packages[index]}",
+      ...${name},
+    }`);
+	const hasModule = localJsPath !== void 0;
+	const hasStyles = importStyles && localCssPath !== void 0;
+	if (hasModule || hasStyles) {
+		if (hasStyles) imports.push(`import '${localCssPath}';`);
+		if (hasModule) {
+			const moduleName = `module${counter}`;
+			imports.push(`import * as ${moduleName} from '${localJsPath}';`);
+			exports.push(`{
+        id: "${LOCAL_PACKAGE_ID}",
+        ...${moduleName},
+      }`);
+		}
+	}
+	const exportStatement = `export default [${exports.length ? `
+        ${exports.join(",\n")}
+    ` : ""}];`;
+	return `${imports.join("\n")}\n\n${exportStatement}`;
+}
+function ensureNodeVersion(minVersion = "24") {
+	const version = process.versions.node;
+	if (!version) return;
+	if (version < minVersion) {
+		console.error(`Node version ${minVersion} or higher is required. Current version: ${version}`);
+		process.exit(1);
+	}
+}
+function runShellScriptPlugin(scriptName, connectPath) {
+	return {
+		name: "vite-plugin-run-shell-script",
+		buildStart() {
+			const scriptPath = join(connectPath, scriptName);
+			if (fs.existsSync(scriptPath)) exec(`sh ${scriptPath}`, (error, stdout, stderr) => {
+				if (error) {
+					console.error(`Error executing the script: ${error.message}`);
+					removeBase64EnvValues(connectPath);
+					return;
+				}
+				if (stderr) console.error(stderr);
+			});
+		}
+	};
+}
+/**
+* Shared helper to modify the <head> tag of an HTML file by transforming its contents.
+*/
+async function modifyHtmlHead(pathToHtml, contents, transform) {
+	if (!existsSync(pathToHtml)) throw new Error(`File ${pathToHtml} does not exist.`);
+	let html = await readFile(pathToHtml, "utf8");
+	html = transform(html, contents);
+	await writeFile(pathToHtml, html, "utf8");
+}
+/**
+* Appends the contents to the <head> tag of the index.html file
+*/
+async function appendToHtmlHead(pathToHtml, contents) {
+	return modifyHtmlHead(pathToHtml, contents, (html, contents) => {
+		if (!html.includes("</head>")) throw new Error("No </head> tag found in the HTML file.");
+		return html.replace("</head>", `\n${contents}\n</head>`);
+	});
+}
+/**
+* Prepends the contents to the <head> tag of the index.html file
+*/
+async function prependToHtmlHead(pathToHtml, contents) {
+	return modifyHtmlHead(pathToHtml, contents, (html, contents) => {
+		if (!html.includes("</head>")) throw new Error("No </head> tag found in the HTML file.");
+		return html.replace("<head>", `<head>\n${contents}\n`);
+	});
+}
+function runTsc(outDir) {
+	execSync(`npx tsc --outDir ${outDir}`, { stdio: "inherit" });
+}
+function stripVersionFromPackage(packageName) {
+	const trimmed = packageName.trim();
+	if (!trimmed) return "";
+	const lastAtIndex = trimmed.lastIndexOf("@");
+	if (lastAtIndex > 0) return trimmed.substring(0, lastAtIndex);
+	return trimmed;
+}
+//#endregion
+//#region connect-utils/vite-plugins/dev-external-react.ts
+const REACT_DEPS = [
+	"react",
+	"react-dom",
+	"react/jsx-runtime",
+	"react/jsx-dev-runtime",
+	"react-dom/client"
+];
+const SHIM_PREFIX = "/__ph/dev-react-shim/";
+const VITE_DEPS_PREFIX = "/node_modules/.vite/deps";
+/**
+* Dev-only sibling of `esmExternalRequirePlugin`. The build path externalizes
+* React via Rolldown so an importmap hands the same React instance to both
+* Connect and CDN-served editor packages. Rolldown plugins don't run in
+* `vite createServer`, and Vite's pre-bundled CJS deps only expose a `default`
+* export — so a CDN editor that does `import { lazy } from "react"` would
+* fail with "no named export 'lazy'".
+*
+* This plugin:
+*   1. Forces React into `optimizeDeps.include` so the optimizer always knows
+*      about it.
+*   2. Serves a shim per React module at a stable URL. Each shim imports
+*      from Vite's live pre-bundled URL (sharing Connect's React instance)
+*      and re-exports React's named members so editors importing
+*      `{ lazy }`, `{ jsx }`, etc. work.
+*   3. Rewrites the page importmap to point at those shim URLs.
+*/
+function devReactImportmapPlugin() {
+	let namedExports = /* @__PURE__ */ new Map();
+	return {
+		name: "ph-dev-react-importmap",
+		apply: "serve",
+		config: () => ({ optimizeDeps: { include: REACT_DEPS } }),
+		configureServer(server) {
+			const requireFromRoot = createRequire(path.join(server.config.root, "package.json"));
+			namedExports = new Map(REACT_DEPS.map((id) => {
+				try {
+					const mod = requireFromRoot(id);
+					return [id, Object.keys(mod).filter((k) => k !== "default")];
+				} catch {
+					return [id, []];
+				}
+			}));
+			server.middlewares.use((req, res, next) => {
+				if (!req.url?.startsWith(SHIM_PREFIX)) return next();
+				const id = req.url.slice(21).replace(/\.js(\?.*)?$/, "");
+				if (!REACT_DEPS.includes(id)) return next();
+				const optimizer = server.environments.client.depsOptimizer;
+				const info = optimizer?.metadata.optimized[id] ?? optimizer?.metadata.discovered[id];
+				if (!optimizer || !info) {
+					res.statusCode = 404;
+					res.end();
+					return;
+				}
+				const browserHash = info.browserHash ?? optimizer.metadata.browserHash;
+				const depUrl = `${VITE_DEPS_PREFIX}/${path.basename(info.file)}?v=${browserHash}`;
+				const names = namedExports.get(id) ?? [];
+				res.setHeader("Content-Type", "application/javascript");
+				res.end(`import * as M from ${JSON.stringify(depUrl)};\nconst ns = M.default ?? M;\nexport default ns;\n` + (names.length ? `export const { ${names.join(", ")} } = ns;\n` : ""));
+			});
+		},
+		transformIndexHtml: {
+			order: "post",
+			handler(html, ctx) {
+				const browserHash = ctx.server?.environments.client.depsOptimizer?.metadata.browserHash;
+				if (!browserHash) return;
+				const imports = Object.fromEntries(REACT_DEPS.map((id) => [id, `${SHIM_PREFIX}${id}.js?v=${browserHash}`]));
+				return html.replace(/<script type="importmap">[\s\S]*?<\/script>/, `<script type="importmap">${JSON.stringify({ imports }, null, 2)}<\/script>`);
+			}
+		}
+	};
+}
+//#endregion
+//#region connect-utils/vite-plugins/favicon.ts
+/**
+* Vite plugin to serve the Connect favicon (icon.ico) from the connect package.
+* This ensures the favicon is available in development and included in the production build.
+*/
+function connectFaviconPlugin() {
+	return {
+		name: "copy-connect-favicon",
+		configureServer(server) {
+			server.middlewares.use("/icon.ico", (_req, res, next) => {
+				server.pluginContainer.resolveId("@powerhousedao/connect/assets/icon.ico").then((resolved) => {
+					if (!resolved) return next();
+					res.setHeader("Content-Type", "image/x-icon");
+					res.end(readFileSync(resolved.id));
+				}).catch(() => next());
+			});
+		},
+		async generateBundle(_options, bundle) {
+			try {
+				if ("icon.ico" in bundle) return;
+				const resolved = await this.resolve("@powerhousedao/connect/assets/icon.ico");
+				if (!resolved) return;
+				this.emitFile({
+					type: "asset",
+					fileName: "icon.ico",
+					source: readFileSync(resolved.id)
+				});
+			} catch {}
+		}
+	};
+}
+//#endregion
+//#region connect-utils/vite-plugins/ph-bundled-packages.ts
+const VIRTUAL_ID = "ph-bundled-packages-virtual";
+const RESOLVED_VIRTUAL_ID = "\0virtual:" + VIRTUAL_ID;
+function readBundledPackageVersion(projectRoot, name) {
+	try {
+		const raw = fs.readFileSync(path.join(projectRoot, "node_modules", name, "package.json"), "utf-8");
+		const pkg = JSON.parse(raw);
+		return typeof pkg.version === "string" ? pkg.version : void 0;
+	} catch {
+		return;
+	}
+}
+function makeRegisterModule(packages, projectRoot) {
+	if (packages.length === 0) return "export default () => {};\n";
+	const imports = [];
+	const calls = [];
+	packages.forEach((name, i) => {
+		const moduleName = `pkg${i}`;
+		const version = readBundledPackageVersion(projectRoot, name);
+		imports.push(`import * as ${moduleName} from ${JSON.stringify(name)};`);
+		imports.push(`import ${JSON.stringify(`${name}/style.css`)};`);
+		calls.push(`  pm.addLocalPackage(${JSON.stringify(name)}, ${moduleName}, ${JSON.stringify(version)});`);
+	});
+	return `${imports.join("\n")}\n\nexport default function register(pm) {\n${calls.join("\n")}\n};\n`;
+}
+/**
+* Emits a virtual module `ph-bundled-packages-virtual` whose default export
+* is a `register(packageManager)` function. When called at runtime (from
+* Connect's bootstrap), it registers each bundled package with the package
+* manager the same way Common/Vetra are registered — meaning they work
+* offline without the registry being reachable.
+*
+* When the list is empty, the module exports a no-op function so Connect's
+* bootstrap code can always import it unconditionally.
+*/
+function phBundledPackagesPlugin(options) {
+	const projectRoot = options.projectRoot ?? process.cwd();
+	const moduleSource = makeRegisterModule(options.packages, projectRoot);
+	return {
+		name: "vite-plugin-ph-bundled-packages",
+		enforce: "pre",
+		resolveId(id) {
+			if (id === VIRTUAL_ID) return RESOLVED_VIRTUAL_ID;
+		},
+		load(id) {
+			if (id === RESOLVED_VIRTUAL_ID) return moduleSource;
+		}
+	};
+}
+//#endregion
+//#region connect-utils/vite-plugins/ph-packages.ts
+function readProjectPackageInfo(projectRoot) {
+	if (!projectRoot) return null;
+	try {
+		const raw = fs.readFileSync(path.join(projectRoot, "package.json"), "utf-8");
+		const pkg = JSON.parse(raw);
+		if (typeof pkg.name !== "string" || typeof pkg.version !== "string") return null;
+		return {
+			name: pkg.name,
+			version: pkg.version
+		};
+	} catch {
+		return null;
+	}
+}
+function phPackagesPlugin(options) {
+	const localPackage = readProjectPackageInfo(options.projectRoot ?? process.cwd());
+	const content = JSON.stringify({
+		packages: options.packages,
+		localPackage
+	}, null, 2);
+	return {
+		name: "vite-plugin-ph-packages",
+		configureServer(server) {
+			server.middlewares.use((req, res, next) => {
+				if (req.url?.endsWith("/ph-packages.json")) {
+					res.setHeader("Content-Type", "application/json");
+					res.end(content);
+					return;
+				}
+				next();
+			});
+		},
+		hotUpdate: {
+			order: "pre",
+			handler(ctx) {
+				return ctx.modules.filter((mod) => {
+					if (mod.importers.size > 1) return true;
+					return !mod.importers.values().next().value?.file?.endsWith(".css");
+				});
+			}
+		},
+		generateBundle() {
+			this.emitFile({
+				type: "asset",
+				fileName: "ph-packages.json",
+				source: content
+			});
+		}
+	};
+}
+//#endregion
+//#region connect-utils/vite-config.ts
+const REACT_VERSION = "19.2.0";
+const REACT_IMPORTMAP_IMPORTS = {
+	react: `https://esm.sh/react@${REACT_VERSION}`,
+	"react/": `https://esm.sh/react@${REACT_VERSION}/`,
+	"react-dom": `https://esm.sh/react-dom@${REACT_VERSION}`,
+	"react-dom/": `https://esm.sh/react-dom@${REACT_VERSION}/`
+};
+function getConnectHtmlTags(options = {}) {
+	const { registryUrl, injectTo = "head" } = options;
+	return [
+		{
+			tag: "meta",
+			attrs: {
+				"http-equiv": "Content-Security-Policy",
+				content: `script-src 'self' 'unsafe-inline' 'unsafe-eval' https://esm.sh${registryUrl ? " " + registryUrl : ""}; object-src 'none'; base-uri 'self';`
+			},
+			injectTo
+		},
+		{
+			tag: "meta",
+			attrs: {
+				property: "og:title",
+				content: "Connect"
+			},
+			injectTo
+		},
+		{
+			tag: "meta",
+			attrs: {
+				property: "og:type",
+				content: "website"
+			},
+			injectTo
+		},
+		{
+			tag: "meta",
+			attrs: {
+				property: "og:url",
+				content: "https://apps.powerhouse.io/powerhouse/connect/"
+			},
+			injectTo
+		},
+		{
+			tag: "meta",
+			attrs: {
+				property: "og:description",
+				content: "Navigate your organisation’s toughest operational challenges and steer your contributors to success with Connect. A navigation, collaboration and reporting tool for decentralised and open organisation."
+			},
+			injectTo
+		},
+		{
+			tag: "meta",
+			attrs: {
+				property: "og:image",
+				content: "https://cf-ipfs.com/ipfs/bafkreigrmclndf2jpbolaq22535q2sw5t44uad3az3dpvkzrnt4lpjt63e"
+			},
+			injectTo
+		},
+		{
+			tag: "meta",
+			attrs: {
+				name: "twitter:card",
+				content: "summary_large_image"
+			},
+			injectTo
+		},
+		{
+			tag: "meta",
+			attrs: {
+				name: "twitter:image",
+				content: "https://cf-ipfs.com/ipfs/bafkreigrmclndf2jpbolaq22535q2sw5t44uad3az3dpvkzrnt4lpjt63e"
+			},
+			injectTo
+		},
+		{
+			tag: "meta",
+			attrs: {
+				name: "twitter:title",
+				content: "Connect"
+			},
+			injectTo
+		},
+		{
+			tag: "meta",
+			attrs: {
+				name: "twitter:description",
+				content: "Navigate your organisation’s toughest operational challenges and steer your contributors to success with Connect. A navigation, collaboration and reporting tool for decentralised and open organisation."
+			},
+			injectTo
+		}
+	];
+}
+function viteLogger({ silence }) {
+	const logger = createLogger();
+	const loggerWarn = logger.warn.bind(logger);
+	const loggerError = logger.error.bind(logger);
+	logger.warn = (msg, options) => {
+		if (silence?.warnings?.some((warning) => msg.includes(warning))) return;
+		loggerWarn(msg, options);
+	};
+	logger.error = (msg, options) => {
+		if (silence?.errors?.some((error) => msg.includes(error))) return;
+		loggerError(msg, options);
+	};
+	return logger;
+}
+function getPackageNamesFromPowerhouseConfig({ packages }) {
+	if (!packages) return [];
+	return packages.map((p) => p.version && p.provider !== "local" ? `${p.packageName}@${p.version}` : p.packageName);
+}
+function getLocalPackageNamesFromPowerhouseConfig({ packages }) {
+	if (!packages) return [];
+	return packages.filter((p) => p.provider === "local").map((p) => p.packageName);
+}
+function getConnectBaseViteConfig(options) {
+	const mode = options.mode;
+	const fileEnv = loadEnv(mode, options.envDir ?? options.dirname, "PH_");
+	const env = loadConnectEnv({
+		processEnv: process.env,
+		fileEnv
+	});
+	setConnectEnv(env);
+	const phConfigPath = env.PH_CONFIG_PATH ?? join(options.dirname, "powerhouse.config.json");
+	const phConfig = options.powerhouseConfig ?? getConfig(phConfigPath);
+	const packagesFromConfig = getPackageNamesFromPowerhouseConfig(phConfig);
+	const localPackagesFromConfig = getLocalPackageNamesFromPowerhouseConfig(phConfig);
+	const phPackages = env.PH_PACKAGES?.split(",") ?? packagesFromConfig;
+	const phPackageRegistryUrl = env.PH_CONNECT_PACKAGES_REGISTRY ?? phConfig.packageRegistryUrl ?? null;
+	const authToken = env.PH_SENTRY_AUTH_TOKEN;
+	const org = env.PH_SENTRY_ORG;
+	const project = env.PH_SENTRY_PROJECT;
+	const release = env.PH_CONNECT_SENTRY_RELEASE || env.PH_CONNECT_VERSION;
+	const uploadSentrySourcemaps = authToken && org && project;
+	const connectHtmlTags = getConnectHtmlTags({ registryUrl: phPackageRegistryUrl });
+	const plugins = [
+		tailwind(),
+		react(),
+		createHtmlPlugin({
+			minify: false,
+			inject: { tags: [...connectHtmlTags, {
+				tag: "script",
+				attrs: { type: "importmap" },
+				children: JSON.stringify({ imports: REACT_IMPORTMAP_IMPORTS }, null, 2),
+				injectTo: "head-prepend"
+			}] }
+		})
+	];
+	if (uploadSentrySourcemaps) plugins.push(import("@sentry/vite-plugin").then(({ sentryVitePlugin }) => sentryVitePlugin({
+		release: {
+			name: release ?? "unknown",
+			inject: false
+		},
+		authToken,
+		org,
+		project,
+		bundleSizeOptimizations: { excludeDebugStatements: true },
+		reactComponentAnnotation: { enabled: true }
+	})));
+	const customLogger = process.env.LOG_LEVEL === "debug" || env.PH_CONNECT_LOG_LEVEL === "debug" ? void 0 : viteLogger({ silence: {
+		warnings: ["@import must precede all other statements (besides @charset or empty @layer)"],
+		errors: ["Unterminated string literal"]
+	} });
+	const reactExternal = [
+		"react",
+		"react-dom",
+		"react/jsx-runtime",
+		"react-dom/client"
+	];
+	return {
+		configFile: false,
+		mode,
+		server: { watch: { ignored: ["**/backup-documents/**", "**/.ph/**"] } },
+		resolve: {
+			dedupe: ["react", "react-dom"],
+			tsconfigPaths: true
+		},
+		define: { PH_PACKAGE_REGISTRY_URL: `"${phPackageRegistryUrl}"` },
+		customLogger,
+		envPrefix: ["PH_CONNECT_"],
+		optimizeDeps: {
+			include: [
+				"document-model",
+				"zod",
+				"@powerhousedao/design-system/connect",
+				"@powerhousedao/reactor-browser",
+				"@powerhousedao/document-engineering"
+			],
+			exclude: ["@electric-sql/pglite", "@electric-sql/pglite-tools"]
+		},
+		plugins: [
+			phPackagesPlugin({
+				packages: phPackages,
+				projectRoot: options.dirname
+			}),
+			phBundledPackagesPlugin({
+				packages: localPackagesFromConfig,
+				projectRoot: options.dirname
+			}),
+			devReactImportmapPlugin(),
+			...plugins,
+			esmExternalRequirePlugin({ external: reactExternal }),
+			connectFaviconPlugin()
+		],
+		worker: { format: "es" },
+		build: { sourcemap: true }
+	};
+}
+//#endregion
+export { DEFAULT_CONNECT_OUTDIR, EXTERNAL_PACKAGES_IMPORT, IMPORT_SCRIPT_FILE, LOCAL_PACKAGE_ID, PH_DIR_NAME, appendToHtmlHead, backupIndexHtml, commonConnectOptionsToEnv, copyConnect, ensureNodeVersion, getConnectBaseViteConfig, getConnectHtmlTags, makeImportScriptFromPackages, phPackagesPlugin, prependToHtmlHead, readJsonFile, removeBase64EnvValues, resolveConnectBundle, resolveConnectPackageJson, resolveConnectPublicDir, resolvePackage, resolveViteConfigPath, runShellScriptPlugin, runTsc, stripVersionFromPackage };
+
+//# sourceMappingURL=index.mjs.map