npm - @powerhousedao/builder-tools - Versions diffs - 6.0.0-dev.17 → 6.0.0-dev.171 - Mend

@powerhousedao/builder-tools 6.0.0-dev.17 → 6.0.0-dev.171

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (367) hide show

package/dist/index.d.mts ADDED Viewed

@@ -0,0 +1,174 @@
+import { CommonServerOptions, HtmlTagDescriptor, InlineConfig, Plugin } from "vite";
+import { PowerhouseConfig } from "@powerhousedao/config";
+//#region connect-utils/constants.d.ts
+declare const EXTERNAL_PACKAGES_IMPORT = "PH:EXTERNAL_PACKAGES";
+declare const IMPORT_SCRIPT_FILE = "external-packages.js";
+declare const LOCAL_PACKAGE_ID = "ph:local-package";
+declare const PH_DIR_NAME = ".ph";
+//#endregion
+//#region connect-utils/types.d.ts
+type IConnectOptions = {
+  mode: string;
+  dirname: string;
+  envDir?: string;
+  powerhouseConfig?: PowerhouseConfig;
+  watchTimeout?: number;
+};
+type ConnectCommonOptions = {
+  base?: string;
+  mode?: string;
+  configFile?: string;
+  projectRoot?: string;
+  viteConfigFile?: string;
+  disableLocalPackage?: boolean;
+  defaultDrivesUrl?: string[];
+  drivesPreserveStrategy?: "preserve-all" | "preserve-by-url-and-detach";
+};
+type ViteDevOptions = Pick<CommonServerOptions, "port" | "host" | "open" | "cors" | "strictPort"> & {
+  force?: boolean;
+};
+type ConnectStudioOptions = ConnectCommonOptions & {
+  devServerOptions?: ViteDevOptions;
+  printUrls?: boolean;
+  bindCLIShortcuts?: boolean;
+};
+type ConnectBuildOptions = ConnectCommonOptions & {
+  outDir?: string;
+};
+type ConnectPreviewOptions = ConnectCommonOptions & Omit<ViteDevOptions, "cors"> & {
+  outDir?: string;
+  printUrls?: boolean;
+  bindCLIShortcuts?: boolean;
+};
+//#endregion
+//#region connect-utils/helpers.d.ts
+declare const DEFAULT_CONNECT_OUTDIR: ".ph/connect-build/dist/";
+declare function commonConnectOptionsToEnv(options: ConnectCommonOptions): void;
+declare function resolveViteConfigPath(options: Pick<ConnectCommonOptions, "projectRoot" | "viteConfigFile">): string;
+declare function resolvePackage(packageName: string, root?: string): string;
+declare function resolveConnectPackageJson(root?: string): JSON | null;
+/**
+ * Finds the dist dir of Connect on the local machine
+ */
+declare function resolveConnectBundle(root?: string): string;
+declare function resolveConnectPublicDir(root?: string): string;
+/**
+ * Copies the Connect dist dir to the target path
+ */
+declare function copyConnect(sourcePath: string, targetPath: string): void;
+/**
+ * Backs up the index.html file
+ *
+ * Needed when running the Connect Studio dev server on Windows
+ */
+declare function backupIndexHtml(appPath: string, restore?: boolean): void;
+declare function removeBase64EnvValues(appPath: string): void;
+declare function readJsonFile(filePath: string): PowerhouseConfig | 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.
+ */
+declare function makeImportScriptFromPackages(args: {
+  packages: string[];
+  importStyles?: boolean;
+  localJsPath?: string;
+  localCssPath?: string;
+}): string;
+declare function ensureNodeVersion(minVersion?: string): void;
+declare function runShellScriptPlugin(scriptName: string, connectPath: string): Plugin;
+/**
+ * Appends the contents to the <head> tag of the index.html file
+ */
+declare function appendToHtmlHead(pathToHtml: string, contents: string): Promise<void>;
+/**
+ * Prepends the contents to the <head> tag of the index.html file
+ */
+declare function prependToHtmlHead(pathToHtml: string, contents: string): Promise<void>;
+declare function runTsc(outDir: string): void;
+declare function stripVersionFromPackage(packageName: string): string;
+//#endregion
+//#region connect-utils/vite-config.d.ts
+declare function getConnectHtmlTags(options?: {
+  registryUrl?: string | null;
+  injectTo?: HtmlTagDescriptor["injectTo"];
+}): [{
+  readonly tag: "meta";
+  readonly attrs: {
+    readonly "http-equiv": "Content-Security-Policy";
+    readonly content: `script-src 'self' 'unsafe-inline' 'unsafe-eval' https://esm.sh${string}; object-src 'none'; base-uri 'self';`;
+  };
+  readonly injectTo: "head" | "body" | "head-prepend" | "body-prepend";
+}, {
+  readonly tag: "meta";
+  readonly attrs: {
+    readonly property: "og:title";
+    readonly content: "Connect";
+  };
+  readonly injectTo: "head" | "body" | "head-prepend" | "body-prepend";
+}, {
+  readonly tag: "meta";
+  readonly attrs: {
+    readonly property: "og:type";
+    readonly content: "website";
+  };
+  readonly injectTo: "head" | "body" | "head-prepend" | "body-prepend";
+}, {
+  readonly tag: "meta";
+  readonly attrs: {
+    readonly property: "og:url";
+    readonly content: "https://apps.powerhouse.io/powerhouse/connect/";
+  };
+  readonly injectTo: "head" | "body" | "head-prepend" | "body-prepend";
+}, {
+  readonly tag: "meta";
+  readonly attrs: {
+    readonly property: "og:description";
+    readonly 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.";
+  };
+  readonly injectTo: "head" | "body" | "head-prepend" | "body-prepend";
+}, {
+  readonly tag: "meta";
+  readonly attrs: {
+    readonly property: "og:image";
+    readonly content: "https://cf-ipfs.com/ipfs/bafkreigrmclndf2jpbolaq22535q2sw5t44uad3az3dpvkzrnt4lpjt63e";
+  };
+  readonly injectTo: "head" | "body" | "head-prepend" | "body-prepend";
+}, {
+  readonly tag: "meta";
+  readonly attrs: {
+    readonly name: "twitter:card";
+    readonly content: "summary_large_image";
+  };
+  readonly injectTo: "head" | "body" | "head-prepend" | "body-prepend";
+}, {
+  readonly tag: "meta";
+  readonly attrs: {
+    readonly name: "twitter:image";
+    readonly content: "https://cf-ipfs.com/ipfs/bafkreigrmclndf2jpbolaq22535q2sw5t44uad3az3dpvkzrnt4lpjt63e";
+  };
+  readonly injectTo: "head" | "body" | "head-prepend" | "body-prepend";
+}, {
+  readonly tag: "meta";
+  readonly attrs: {
+    readonly name: "twitter:title";
+    readonly content: "Connect";
+  };
+  readonly injectTo: "head" | "body" | "head-prepend" | "body-prepend";
+}, {
+  readonly tag: "meta";
+  readonly attrs: {
+    readonly name: "twitter:description";
+    readonly 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.";
+  };
+  readonly injectTo: "head" | "body" | "head-prepend" | "body-prepend";
+}];
+declare function getConnectBaseViteConfig(options: IConnectOptions): InlineConfig;
+//#endregion
+//#region connect-utils/vite-plugins/ph-packages.d.ts
+type PhPackagesPluginOptions = {
+  packages: string[];
+};
+declare function phPackagesPlugin(options: PhPackagesPluginOptions): Plugin;
+//#endregion
+export { ConnectBuildOptions, ConnectCommonOptions, ConnectPreviewOptions, ConnectStudioOptions, DEFAULT_CONNECT_OUTDIR, EXTERNAL_PACKAGES_IMPORT, IConnectOptions, IMPORT_SCRIPT_FILE, LOCAL_PACKAGE_ID, PH_DIR_NAME, PhPackagesPluginOptions, ViteDevOptions, appendToHtmlHead, backupIndexHtml, commonConnectOptionsToEnv, copyConnect, ensureNodeVersion, getConnectBaseViteConfig, getConnectHtmlTags, makeImportScriptFromPackages, phPackagesPlugin, prependToHtmlHead, readJsonFile, removeBase64EnvValues, resolveConnectBundle, resolveConnectPackageJson, resolveConnectPublicDir, resolvePackage, resolveViteConfigPath, runShellScriptPlugin, runTsc, stripVersionFromPackage };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"index.d.mts","names":[],"sources":["../connect-utils/constants.ts","../connect-utils/types.ts","../connect-utils/helpers.ts","../connect-utils/vite-config.ts","../connect-utils/vite-plugins/ph-packages.ts"],"mappings":";;;;cAAa,wBAAA;AAAA,cACA,kBAAA;AAAA,cACA,gBAAA;AAAA,cACA,WAAA;;;KCAD,eAAA;EACV,IAAA;EACA,OAAA;EACA,MAAA;EACA,gBAAA,GAAmB,gBAAA;EACnB,YAAA;AAAA;AAAA,KAGU,oBAAA;EAEV,IAAA;EAEA,IAAA;EAEA,UAAA;EAEA,WAAA;EAEA,cAAA;EAEA,mBAAA;EAEA,gBAAA;EAEA,sBAAA;AAAA;AAAA,KAGU,cAAA,GAAiB,IAAA,CAC3B,mBAAA;EAEI,KAAA;AAAA;AAAA,KAEM,oBAAA,GAAuB,oBAAA;EACjC,gBAAA,GAAmB,cAAA;EACnB,SAAA;EACA,gBAAA;AAAA;AAAA,KAGU,mBAAA,GAAsB,oBAAA;EAEhC,MAAA;AAAA;AAAA,KAGU,qBAAA,GAAwB,oBAAA,GAClC,IAAA,CAAK,cAAA;EAEH,MAAA;EACA,SAAA;EACA,gBAAA;AAAA;;;cCvCS,sBAAA;AAAA,iBAEG,yBAAA,CAA0B,OAAA,EAAS,oBAAA;AAAA,iBAqCnC,qBAAA,CACd,OAAA,EAAS,IAAA,CAAK,oBAAA;AAAA,iBAMA,cAAA,CAAe,WAAA,UAAqB,IAAA;AAAA,iBAMpC,yBAAA,CAA0B,IAAA,YAAoB,IAAA;;AF/D9D;;iBEgFgB,oBAAA,CAAqB,IAAA;AAAA,iBASrB,uBAAA,CAAwB,IAAA;;AFxFxC;;iBEmGgB,WAAA,CAAY,UAAA,UAAoB,UAAA;;;AFlGhD;;;iBEmHgB,eAAA,CAAgB,OAAA,UAAiB,OAAA;AAAA,iBAWjC,qBAAA,CAAsB,OAAA;AAAA,iBAmCtB,YAAA,CAAa,QAAA,WAAmB,gBAAA;;;ADjKhD;iBC+KgB,4BAAA,CAA6B,IAAA;EAC3C,QAAA;EACA,YAAA;EACA,WAAA;EACA,YAAA;AAAA;AAAA,iBAsDc,iBAAA,CAAkB,UAAA;AAAA,iBAclB,oBAAA,CACd,UAAA,UACA,WAAA,WACC,MAAA;;;;iBAwCmB,gBAAA,CAAiB,UAAA,UAAoB,QAAA,WAAgB,OAAA;;;;iBAYrD,iBAAA,CAAkB,UAAA,UAAoB,QAAA,WAAgB,OAAA;AAAA,iBAS5D,MAAA,CAAO,MAAA;AAAA,iBAMP,uBAAA,CAAwB,WAAA;;;iBC5SxB,kBAAA,CACd,OAAA;EACE,WAAA;EACA,QAAA,GAAW,iBAAA;AAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2HC,wBAAA,CAAyB,OAAA,EAAS,eAAA,GAAe,YAAA;;;KChJrD,uBAAA;EACV,QAAA;AAAA;AAAA,iBAGc,gBAAA,CAAiB,OAAA,EAAS,uBAAA,GAA0B,MAAA"}

package/dist/index.mjs ADDED Viewed

@@ -0,0 +1,472 @@
+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 { sentryVitePlugin } from "@sentry/vite-plugin";
+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/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-packages.ts
+function phPackagesPlugin(options) {
+	const content = JSON.stringify({ packages: options.packages }, 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
+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.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 connectHtmlTags = getConnectHtmlTags({ registryUrl: phPackageRegistryUrl });
+	const plugins = [
+		tailwind(),
+		react(),
+		createHtmlPlugin({
+			minify: false,
+			inject: { tags: [...connectHtmlTags, {
+				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"]
+	} });
+	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 }),
+			...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