@powerhousedao/builder-tools 6.0.0-dev.105 → 6.0.0-dev.106

package/dist/index.mjs

@@ -0,0 +1,696 @@
+import { builtinModules, createRequire } from "node:module";
+import { exec, execSync } from "node:child_process";
+import fs, { existsSync } from "node:fs";
+import fs$1, { readFile, writeFile } from "node:fs/promises";
+import path, { basename, dirname, join, resolve } from "node:path";
+import { cwd } from "node:process";
+import { loadConnectEnv, setConnectEnv } from "@powerhousedao/shared/connect";
+import { getConfig } from "@powerhousedao/config/node";
+import { sentryVitePlugin } from "@sentry/vite-plugin";
+import tailwind from "@tailwindcss/vite";
+import react from "@vitejs/plugin-react";
+import { createLogger, loadEnv } from "vite";
+import { createHtmlPlugin } from "vite-plugin-html";
+import tsconfigPaths from "vite-tsconfig-paths";
+import fs$2 from "fs/promises";
+import MagicString from "magic-string";
+import { build } from "esbuild";
+import fg from "fast-glob";
+import { exports } from "resolve.exports";
+//#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-config.ts
+const connectClientConfig = { meta: [
+	{
+		tag: "meta",
+		attrs: {
+			"http-equiv": "Content-Security-Policy",
+			content: "script-src 'self' 'unsafe-inline' 'unsafe-eval' https://esm.sh http://localhost:8080; object-src 'none'; base-uri 'self';"
+		}
+	},
+	{
+		tag: "meta",
+		attrs: {
+			property: "og:title",
+			content: "Connect"
+		}
+	},
+	{
+		tag: "meta",
+		attrs: {
+			property: "og:type",
+			content: "website"
+		}
+	},
+	{
+		tag: "meta",
+		attrs: {
+			property: "og:url",
+			content: "https://apps.powerhouse.io/powerhouse/connect/"
+		}
+	},
+	{
+		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."
+		}
+	},
+	{
+		tag: "meta",
+		attrs: {
+			property: "og:image",
+			content: "https://cf-ipfs.com/ipfs/bafkreigrmclndf2jpbolaq22535q2sw5t44uad3az3dpvkzrnt4lpjt63e"
+		}
+	},
+	{
+		tag: "meta",
+		attrs: {
+			name: "twitter:card",
+			content: "summary_large_image"
+		}
+	},
+	{
+		tag: "meta",
+		attrs: {
+			name: "twitter:image",
+			content: "https://cf-ipfs.com/ipfs/bafkreigrmclndf2jpbolaq22535q2sw5t44uad3az3dpvkzrnt4lpjt63e"
+		}
+	},
+	{
+		tag: "meta",
+		attrs: {
+			name: "twitter:title",
+			content: "Connect"
+		}
+	},
+	{
+		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."
+		}
+	}
+] };
+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.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 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 plugins = [
+		tsconfigPaths(),
+		tailwind(),
+		react(),
+		createHtmlPlugin({
+			minify: false,
+			inject: { tags: [...connectClientConfig.meta.map((meta) => ({
+				...meta,
+				injectTo: "head"
+			})), {
+				tag: "script",
+				attrs: { type: "importmap" },
+				children: JSON.stringify({ imports: {
+					react: "https://esm.sh/react@19.2.0",
+					"react/": "https://esm.sh/react@19.2.0/",
+					"react-dom": "https://esm.sh/react-dom@19.2.0",
+					"react-dom/": "https://esm.sh/react-dom@19.2.0/"
+				} }, null, 2),
+				injectTo: "head-prepend"
+			}] }
+		})
+	];
+	if (uploadSentrySourcemaps) plugins.push(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"]
+	} });
+	return {
+		configFile: false,
+		mode,
+		define: {
+			PH_PACKAGES: phPackages,
+			PH_PACKAGE_REGISTRY_URL: `"${phPackageRegistryUrl}"`
+		},
+		customLogger,
+		envPrefix: ["PH_CONNECT_"],
+		optimizeDeps: { exclude: ["@electric-sql/pglite", "@electric-sql/pglite-tools"] },
+		build: { rollupOptions: { external: [
+			"react",
+			"react-dom",
+			"react/jsx-runtime",
+			"react-dom/client"
+		] } },
+		plugins,
+		worker: { format: "es" }
+	};
+}
+//#endregion
+//#region connect-utils/vite-plugins/base.ts
+const externalIds = [/^react(-dom)?(\/.*)?$/, /^node:.*$/];
+function viteIgnoreStaticImport(_importKeys) {
+	const importKeys = _importKeys.filter((key) => typeof key === "string" || key instanceof RegExp);
+	return {
+		name: "vite-plugin-ignore-static-import",
+		enforce: "pre",
+		configResolved(resolvedConfig) {
+			const values = importKeys.map((key) => typeof key === "string" ? key : key.source);
+			const reg = new RegExp(`("|')\\/@id\\/(${values.join("|")})(\\/[^"'\\\\]*)?\\1`, "g");
+			resolvedConfig.plugins.push({
+				name: "vite-plugin-ignore-static-import-replace-idprefix",
+				transform: (code) => {
+					const s = new MagicString(code);
+					const matches = code.matchAll(reg);
+					let modified = false;
+					for (const match of matches) {
+						s.overwrite(match.index, match.index + match[0].length, match[0].replace("/@id/", ""));
+						modified = true;
+					}
+					if (!modified) return null;
+					return {
+						code: s.toString(),
+						map: s.generateMap({ hires: true })
+					};
+				}
+			});
+		},
+		resolveId: (id) => {
+			if (importKeys.some((key) => typeof key === "string" ? key === id : key.test(id))) return {
+				id,
+				external: true
+			};
+		},
+		load(id) {
+			if (importKeys.some((key) => typeof key === "string" ? key === id : key.test(id))) return "";
+		}
+	};
+}
+function viteReplaceImports(imports) {
+	const importKeys = Object.keys(imports);
+	return {
+		name: "vite-plugin-connect-replace-imports",
+		enforce: "pre",
+		config(config) {
+			const resolve = config.resolve ?? {};
+			const alias = resolve.alias;
+			let resolvedAlias;
+			if (Array.isArray(alias)) {
+				const arrayAlias = [...alias];
+				arrayAlias.push(...Object.entries(imports).map(([find, replacement]) => ({
+					find,
+					replacement
+				})));
+				resolvedAlias = arrayAlias;
+			} else if (typeof alias === "object") resolvedAlias = {
+				...alias,
+				...imports
+			};
+			else if (typeof alias === "undefined") resolvedAlias = { ...imports };
+			else console.error("resolve.alias was not recognized");
+			if (resolvedAlias) {
+				resolve.alias = resolvedAlias;
+				config.resolve = resolve;
+			}
+		},
+		resolveId: (id) => {
+			if (importKeys.includes(id)) return {
+				id,
+				external: true
+			};
+		}
+	};
+}
+async function findPackageJson(packageName) {
+	let packagePath;
+	try {
+		packagePath = createRequire(process.cwd()).resolve(packageName, { paths: [process.cwd()] });
+	} catch (err) {
+		throw new Error(`Failed to resolve package: ${packageName}`, { cause: err });
+	}
+	let dir = dirname(packagePath);
+	while (dir !== "/" && dir !== "." && dir !== "node_modules") {
+		if (basename(dir) === "dist") dir = dirname(dir);
+		const pkgJsonPath = `${dir}/package.json`;
+		try {
+			await fs$2.access(pkgJsonPath);
+			const file = await fs$2.readFile(pkgJsonPath, "utf-8");
+			return {
+				packageJson: JSON.parse(file),
+				path: dir
+			};
+		} catch {
+			dir = dirname(dir);
+		}
+	}
+	throw new Error(`package.json not found for ${packageName}`);
+}
+//#endregion
+//#region connect-utils/vite-plugins/importmap.ts
+const nodeModules = builtinModules.concat(builtinModules.map((m) => `node:${m}`));
+/**
+* Resolves glob exports like `"./*": "./dist/*.js"` and `"./utils/*": "./dist/utils/*.js"`
+* into actual file mappings.
+*
+* @param {string} exportName - The export pattern (e.g., `"./*"` or `"./utils/*"`).
+* @param {string} exportPath - The actual path pattern (e.g., `"./dist/*.js"`).
+* @param {string} srcPath - The package root directory where the exports are located.
+* @returns {Promise<Record<string, string>>} - A mapping of export names to resolved paths.
+*/
+async function resolveGlobExport(exportName, exportPath, srcPath) {
+	const resolvedExports = /* @__PURE__ */ new Map();
+	const hasGloblExport = exportName.endsWith("/*");
+	const globPath = hasGloblExport ? exportPath.replace("*", "**/*") : exportPath;
+	const distPath = exportPath.substring(0, exportPath.lastIndexOf("/*"));
+	const resolvedSrcPath = hasGloblExport ? path.join(srcPath.replace("*", ""), distPath) : srcPath;
+	const files = await fg(path.join(srcPath, globPath));
+	for (const file of files) {
+		const relativeSrcFilePath = path.relative(resolvedSrcPath, file);
+		const exportFilePath = path.relative(srcPath, file);
+		const exportKey = relativeSrcFilePath.replace(path.extname(file), "");
+		const mappedExport = exportName.replace("*", exportKey);
+		resolvedExports.set(mappedExport, {
+			export: `./${relativeSrcFilePath}`,
+			file: exportFilePath
+		});
+	}
+	return resolvedExports;
+}
+async function addExportToMap(exportName, exportPath, srcPath, map) {
+	if (exportName.includes("*")) (await resolveGlobExport(exportName, exportPath, srcPath)).forEach((value, key) => map.set(key, value));
+	else map.set(exportName, {
+		export: exportPath,
+		file: exportPath
+	});
+}
+async function getPackageExports(name, packageJson, srcPath) {
+	const entries = /* @__PURE__ */ new Map();
+	const mainExport = exports(packageJson, ".", { browser: true });
+	if (mainExport) for (const entry of mainExport) await addExportToMap(".", entry, srcPath, entries);
+	if (!packageJson.exports) return entries;
+	if (typeof packageJson.exports === "string") {
+		await addExportToMap(name, packageJson.exports, srcPath, entries);
+		return entries;
+	}
+	for (const [key, entry] of Object.entries(packageJson.exports)) if (typeof entry === "string") await addExportToMap(key, entry, srcPath, entries);
+	else {
+		const exportResult = exports(packageJson, key, { browser: true })?.at(0);
+		if (exportResult) await addExportToMap(key, exportResult, srcPath, entries);
+		else console.warn(`No browser exports found for ${name}/${key}`);
+	}
+	const main = entries.get(".");
+	const resolvedExport = (main ? Array.from(entries.entries()).find(([key, entry]) => key != "." && [entry.file, `./${entry.file}`].includes(main.file)) : void 0)?.at(1);
+	if (resolvedExport) entries.set(".", {
+		export: resolvedExport.export,
+		file: resolvedExport.file
+	});
+	return entries;
+}
+function importFromEsmSh(name, version, dependencies) {
+	const lib = `${name}${version ? `@${version}` : ""}`;
+	const query = dependencies?.length ? `&deps=${dependencies.join(",")}` : "";
+	return {
+		[name]: `https://esm.sh/${lib}${query}`,
+		[`${name}/`]: `https://esm.sh/${lib}${query}/`
+	};
+}
+async function importFromNodeModules(name, modulesDir, importMapDeps, baseUrl) {
+	const importMap = {};
+	const { packageJson, path: srcPath } = await findPackageJson(name);
+	const entries = await getPackageExports(name, packageJson, srcPath);
+	if (!entries.size) throw new Error(`No browser exports found for ${name}`);
+	const indexFile = entries.get("")?.export || "index";
+	const fileName = path.basename(entries.get("")?.export || "index", path.extname(indexFile));
+	const outputPath = path.join(modulesDir, name);
+	const buildModule = () => {
+		console.log(`Bundling dependency: ${name}`);
+		return build({
+			entryPoints: Array.from(entries.values()).map((value) => path.join(srcPath, value.file)),
+			outdir: outputPath,
+			bundle: true,
+			format: "esm",
+			platform: "browser",
+			target: "esnext",
+			splitting: true,
+			external: nodeModules.concat(Array.from(importMapDeps)),
+			sourcemap: true,
+			minify: false
+		});
+	};
+	importMap[name] = `./modules/${name}/${fileName}.js`;
+	entries.forEach((entry, key) => {
+		importMap[path.join(name, key)] = path.join(baseUrl, `./modules/${path.join(name, entry.export)}`);
+	});
+	return {
+		importMap,
+		buildModule
+	};
+}
+async function generateImportMap(outputDir, dependencies, baseUrl) {
+	const modulesDir = path.join(outputDir, "/modules");
+	await fs$1.mkdir(modulesDir, { recursive: true });
+	const importMapDeps = new Set(dependencies.map((dep) => typeof dep === "string" ? dep : dep.name));
+	let importMap = {};
+	const buildModules = [];
+	for (const dependency of dependencies) {
+		const isString = typeof dependency === "string";
+		const name = isString ? dependency : dependency.name;
+		const version = isString ? void 0 : dependency.version;
+		const provider = isString ? "node_modules" : dependency.provider;
+		const subDependencies = isString ? void 0 : dependency.dependencies;
+		if (provider === "esm.sh") {
+			const imports = importFromEsmSh(name, version, subDependencies);
+			importMap = {
+				...importMap,
+				...imports
+			};
+		} else if (provider.toString() === "node_modules") {
+			const { importMap: imports, buildModule } = await importFromNodeModules(name, modulesDir, importMapDeps, baseUrl);
+			importMap = {
+				...importMap,
+				...imports
+			};
+			buildModules.push(buildModule);
+		} else throw new Error(`Unsupported provider: ${provider}`);
+	}
+	return {
+		importMap,
+		buildModules: async () => {
+			await Promise.all(buildModules.map((build) => build()));
+		}
+	};
+}
+function addImportMapToHTML(importMap, html) {
+	let newHtml = "";
+	const importMapRegex = /<script type="importmap">(.*?)<\/script>/s;
+	const match = importMapRegex.exec(html);
+	if (match) try {
+		const existingImportMap = JSON.parse(match[1]);
+		existingImportMap.imports = {
+			...existingImportMap.imports,
+			...importMap
+		};
+		const mergedImportMapString = JSON.stringify(existingImportMap, null, 2);
+		newHtml = html.replace(importMapRegex, `<script type="importmap">${mergedImportMapString}<\/script>`);
+	} catch (error) {
+		console.error("⚠️ Error parsing existing import map:", error);
+	}
+	else {
+		const importMapScript = `<script type="importmap">${JSON.stringify({ imports: importMap }, null, 2)}<\/script>`;
+		newHtml = html.replace("</head>", `${importMapScript}\n</head>`);
+	}
+	return newHtml;
+}
+/**
+* Vite plugin to bundle or copy dependencies and inject an import map into `index.html`.
+*
+* @param {string} outputDir - The directory where the modules should be placed.
+* @param {(string | { name: string; provider: string })[]} dependencies -
+*        List of dependencies to process. Can be:
+*        - A string (dependency is copied as is).
+*        - An object `{ name, provide }` where:
+*          - `name` (string): The module name.
+*          - `provider` (string): Where to retrieve the module bundle. Defaults to node_modules.
+*
+* @returns {Plugin} A Vite plugin that processes dependencies and injects an import map.
+*/
+function generateImportMapPlugin(outputDir, dependencies) {
+	let buildModules = void 0;
+	let importMap = {};
+	return [{
+		name: "vite-plugin-importmap",
+		enforce: "post",
+		async configResolved(config) {
+			const result = await generateImportMap(outputDir, dependencies, config.base);
+			importMap = result.importMap;
+			buildModules = result.buildModules;
+		},
+		closeBundle() {
+			return buildModules?.();
+		},
+		configureServer() {
+			return buildModules?.();
+		},
+		transformIndexHtml(html) {
+			return addImportMapToHTML(importMap, html) || html;
+		}
+	}];
+}
+//#endregion
+//#region connect-utils/vite-plugins/studio.ts
+function viteConnectDevStudioPlugin(enabled = false, connectPath, env) {
+	return [enabled && viteIgnoreStaticImport([
+		"react",
+		"react-dom",
+		...externalIds
+	]), {
+		name: "vite-plugin-connect-dev-studio",
+		enforce: "pre",
+		config(config) {
+			if (!config.build) config.build = {};
+			if (!config.build.rollupOptions) config.build.rollupOptions = {};
+			if (!Array.isArray(config.build.rollupOptions.external)) config.build.rollupOptions.external = [];
+			if (enabled) config.build.rollupOptions.external.push(...externalIds);
+		},
+		closeBundle() {
+			if (!enabled) fs.copyFileSync(join(connectPath, "../.env"), join(connectPath, ".env"));
+		}
+	}];
+}
+//#endregion
+export { DEFAULT_CONNECT_OUTDIR, EXTERNAL_PACKAGES_IMPORT, IMPORT_SCRIPT_FILE, LOCAL_PACKAGE_ID, PH_DIR_NAME, appendToHtmlHead, backupIndexHtml, commonConnectOptionsToEnv, connectClientConfig, copyConnect, ensureNodeVersion, externalIds, findPackageJson, generateImportMapPlugin, getConnectBaseViteConfig, makeImportScriptFromPackages, prependToHtmlHead, readJsonFile, removeBase64EnvValues, resolveConnectBundle, resolveConnectPackageJson, resolveConnectPublicDir, resolvePackage, resolveViteConfigPath, runShellScriptPlugin, runTsc, stripVersionFromPackage, viteConnectDevStudioPlugin, viteIgnoreStaticImport, viteReplaceImports };
+
+//# sourceMappingURL=index.mjs.map