@powerhousedao/connect 6.0.0-dev.13 → 6.0.0-dev.131

package/dist/reactor-Be0fd4-f.js

@@ -0,0 +1,586 @@
+import { i as phGlobalConfigFromEnv, t as connectConfig } from "./connect.config-CUbxYkCy.js";
+import { t as toast } from "./toast-iD-70hL8.js";
+import { BrowserLocalStorage, COMMON_PACKAGE_ID, ChannelScheme, DEFAULT_DRIVE_EDITOR_ID, DocumentCache, DocumentChangeType, ReactorBuilder, ReactorClientBuilder, addPHEventHandlers, addRemoteDrive, convertLegacyLibToVetraPackage, createAnalyticsStore, dropAllReactorStorage, extractDriveSlugFromPath, extractNodeSlugFromPath, getDrives, login, refreshReactorDataClient, setDefaultPHGlobalConfig, setDocumentCache, setDrives, setFeatures, setPHToast, setReactorClient, setReactorClientModule, setRenown, setSelectedDrive, setSelectedNode, setVetraPackageManager } from "@powerhousedao/reactor-browser";
+import { ConsoleLogger, documentModelDocumentModelModule, logger, setLogLevel as setLogLevel$1 } from "document-model";
+import { PGlite } from "@electric-sql/pglite";
+import { BrowserKeyStorage, RenownBuilder, RenownCryptoBuilder, createSignatureVerifier } from "@renown/sdk";
+import { Kysely } from "kysely";
+import { PGliteDialect } from "kysely-pglite-dialect";
+import { DocumentModelEditor, GenericDriveExplorer } from "@powerhousedao/powerhouse-vetra-packages/editors";
+import { createState, defaultBaseState } from "@powerhousedao/shared/document-model";
+import { live } from "@electric-sql/pglite/live";
+import { PGliteWorker } from "@electric-sql/pglite/worker";
+import { createRelationalDb } from "@powerhousedao/shared/processors";
+import { driveDocumentModelModule } from "@powerhousedao/shared/document-drive";
+import { OpenFeature } from "@openfeature/web-sdk";
+import * as vetraVetraPackage from "@powerhousedao/vetra";
+//#region src/utils/reactor.ts
+/**
+* Creates a Reactor that plugs into legacy storage but syncs through the new
+* Reactor GQL API.
+*/
+async function createBrowserReactor(documentModelModules, upgradeManifests, renown, documentModelLoader) {
+	const signerConfig = {
+		signer: renown.signer,
+		verifier: createSignatureVerifier()
+	};
+	const jwtHandler = async (url) => {
+		if (!renown.user) return;
+		return renown.getBearerToken({
+			expiresIn: 10,
+			aud: url
+		});
+	};
+	const pg = new PGlite("idb://reactor", { relaxedDurability: true });
+	const logger = new ConsoleLogger(["reactor-client"]);
+	const builder = new ReactorClientBuilder().withLogger(logger).withSigner(signerConfig).withReactorBuilder(new ReactorBuilder().withDocumentModels(documentModelModules).withUpgradeManifests(upgradeManifests).withChannelScheme(ChannelScheme.CONNECT).withJwtHandler(jwtHandler).withKysely(new Kysely({ dialect: new PGliteDialect(pg) })));
+	if (documentModelLoader) builder.withDocumentModelLoader(documentModelLoader);
+	return {
+		...await builder.buildModule(),
+		pg
+	};
+}
+/**
+* Parse default drives from environment variable.
+* Returns an array of drive REST endpoint URLs (e.g., "https://example.com/d/powerhouse").
+*/
+function getDefaultDrivesFromEnv() {
+	const envValue = import.meta.env.PH_CONNECT_DEFAULT_DRIVES_URL;
+	if (!envValue) return [];
+	return envValue.split(",").filter((url) => url.trim().length > 0);
+}
+/**
+* Add default drives for the new reactor via sync manager.
+* @param defaultDriveUrls - Array of drive REST endpoint URLs (e.g., "https://example.com/d/powerhouse")
+*/
+async function addDefaultDrivesForNewReactor(defaultDriveUrls) {
+	for (const url of defaultDriveUrls) try {
+		await addRemoteDrive(url);
+	} catch (error) {
+		console.error(`Failed to add default drive ${url}:`, error);
+	}
+}
+//#endregion
+//#region src/store/document-model.ts
+function loadDocumentModelDocumentModelModule() {
+	const global = documentModelDocumentModelModule.documentModel.global;
+	const name = global.name;
+	const documentType = global.id;
+	return {
+		id: documentType,
+		name,
+		documentType,
+		extension: global.extension,
+		specifications: global.specifications,
+		reducer: documentModelDocumentModelModule.reducer,
+		actions: documentModelDocumentModelModule.actions,
+		utils: documentModelDocumentModelModule.utils,
+		documentModel: createState(defaultBaseState(), global)
+	};
+}
+function loadDriveDocumentModelModule() {
+	const global = driveDocumentModelModule.documentModel.global;
+	const name = global.name;
+	const documentType = global.id;
+	return {
+		id: documentType,
+		name,
+		documentType,
+		extension: global.extension,
+		specifications: global.specifications,
+		reducer: driveDocumentModelModule.reducer,
+		actions: driveDocumentModelModule.actions,
+		utils: driveDocumentModelModule.utils,
+		documentModel: createState(defaultBaseState(), global)
+	};
+}
+//#endregion
+//#region src/store/editor.ts
+function loadGenericDriveExplorerEditorModule() {
+	return {
+		id: DEFAULT_DRIVE_EDITOR_ID,
+		name: "Generic Drive Explorer",
+		documentTypes: ["powerhouse/document-drive"],
+		Component: GenericDriveExplorer.Component
+	};
+}
+function loadDocumentModelEditor() {
+	return {
+		id: "document-model-editor-v2",
+		name: "Document Model Editor",
+		documentTypes: ["powerhouse/document-model"],
+		Component: DocumentModelEditor.Component
+	};
+}
+//#endregion
+//#region src/feature-flags.ts
+/**
+* QueryParamProvider reads feature flags from URL query parameters.
+*
+* Usage:
+*   const params = new URLSearchParams(window.location.search);
+*   const provider = new QueryParamProvider(params);
+*   await OpenFeature.setProviderAndWait(provider);
+*
+* Query parameter format:
+*   ?FEATURE_DUAL_ACTION_CREATE_ENABLED=true&FEATURE_FOO=false
+*/
+var QueryParamProvider = class {
+	runsOn = "client";
+	metadata = { name: "QueryParamProvider" };
+	flags;
+	constructor(searchParams) {
+		this.flags = /* @__PURE__ */ new Map();
+		for (const [key, value] of searchParams.entries()) this.flags.set(key, value);
+	}
+	resolveBooleanEvaluation(flagKey, defaultValue) {
+		const value = this.flags.get(flagKey);
+		if (value === void 0) return {
+			value: defaultValue,
+			reason: "DEFAULT"
+		};
+		return {
+			value: value.toLowerCase() === "true" || value === "1",
+			reason: "STATIC",
+			variant: value
+		};
+	}
+	resolveStringEvaluation(flagKey, defaultValue) {
+		const value = this.flags.get(flagKey);
+		if (value === void 0) return {
+			value: defaultValue,
+			reason: "DEFAULT"
+		};
+		return {
+			value,
+			reason: "STATIC",
+			variant: value
+		};
+	}
+	resolveNumberEvaluation(flagKey, defaultValue) {
+		const value = this.flags.get(flagKey);
+		if (value === void 0) return {
+			value: defaultValue,
+			reason: "DEFAULT"
+		};
+		const numValue = Number(value);
+		if (isNaN(numValue)) return {
+			value: defaultValue,
+			reason: "ERROR",
+			errorCode: "PARSE_ERROR",
+			errorMessage: `Failed to parse "${value}" as a number`
+		};
+		return {
+			value: numValue,
+			reason: "STATIC",
+			variant: value
+		};
+	}
+	resolveObjectEvaluation(flagKey, defaultValue) {
+		const value = this.flags.get(flagKey);
+		if (value === void 0) return {
+			value: defaultValue,
+			reason: "DEFAULT"
+		};
+		try {
+			return {
+				value: JSON.parse(value),
+				reason: "STATIC",
+				variant: value
+			};
+		} catch (error) {
+			return {
+				value: defaultValue,
+				reason: "ERROR",
+				errorCode: "PARSE_ERROR",
+				errorMessage: `Failed to parse JSON: ${error instanceof Error ? error.message : String(error)}`
+			};
+		}
+	}
+};
+/**
+* Initialize OpenFeature with the QueryParamProvider.
+* Reads feature flags from query parameters.
+*/
+async function initFeatureFlags(searchParams) {
+	const params = searchParams ?? (typeof window !== "undefined" ? new URLSearchParams(window.location.search) : new URLSearchParams());
+	const provider = new QueryParamProvider(params);
+	await OpenFeature.setProviderAndWait(provider);
+	const features = /* @__PURE__ */ new Map();
+	const client = OpenFeature.getClient();
+	const inspectorEnabled = params.has(FEATURE_INSPECTOR_ENABLED) ? client.getBooleanValue(FEATURE_INSPECTOR_ENABLED, FEATURE_INSPECTOR_ENABLED_DEFAULT) : connectConfig.content.inspectorEnabled;
+	features.set(FEATURE_INSPECTOR_ENABLED, inspectorEnabled);
+	const logLevelParam = params.get("LOG_LEVEL");
+	if (logLevelParam) {
+		const validLogLevels = [
+			"verbose",
+			"debug",
+			"info",
+			"warn",
+			"error"
+		];
+		if (validLogLevels.includes(logLevelParam.toLowerCase())) {
+			setLogLevel$1(logLevelParam.toLowerCase());
+			logger.info("Log level set to @level via query param", logLevelParam.toLowerCase());
+		} else logger.warn("Invalid LOG_LEVEL query param: @param. Valid values: @validLevels", logLevelParam, validLogLevels.join(", "));
+	}
+	return features;
+}
+const FEATURE_INSPECTOR_ENABLED = "FEATURE_INSPECTOR_ENABLED";
+const FEATURE_INSPECTOR_ENABLED_DEFAULT = false;
+//#endregion
+//#region src/package-manager.ts
+const LOCAL_PACKAGE_NAME = "Local";
+const COMMON_PACKAGE_NAME = "Common";
+const LOCAL_PACKAGES = [
+	LOCAL_PACKAGE_NAME,
+	COMMON_PACKAGE_NAME,
+	"@powerhousedao/vetra"
+];
+var BrowserPackageManager = class {
+	registryUrl;
+	#storage;
+	#packages = /* @__PURE__ */ new Map();
+	#subscribers = /* @__PURE__ */ new Set();
+	#packagesMemo = [];
+	#stylesheets = /* @__PURE__ */ new Map();
+	#localPackage;
+	#cdnUrl;
+	constructor(namespace, registryUrl) {
+		this.#storage = new BrowserLocalStorage(namespace + ":PH_PACKAGES");
+		this.registryUrl = registryUrl;
+		this.#cdnUrl = registryUrl !== null ? this.#toCdnUrl(registryUrl) : null;
+	}
+	#toCdnUrl(baseUrl) {
+		if (baseUrl.includes("/-/cdn")) return baseUrl;
+		return `${baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl}/-/cdn`;
+	}
+	async init(localPackage) {
+		const commonPackageWithMeta = this.#loadCommonPackage();
+		this.#registerPackage(commonPackageWithMeta);
+		const vetraVetraPackageWithMeta = this.#loadVetraPackage();
+		this.#registerPackage(vetraVetraPackageWithMeta);
+		if (localPackage) {
+			this.#localPackage = localPackage;
+			this.#registerPackage({
+				name: LOCAL_PACKAGE_NAME,
+				stylesheetUrl: null,
+				importUrl: null,
+				loadedPackage: localPackage
+			});
+		}
+		for (const packageName of this.#storage.keys()) await this.addPackage(packageName);
+	}
+	get packages() {
+		return this.#packagesMemo;
+	}
+	getPackageSource(packageName) {
+		if (LOCAL_PACKAGES.includes(packageName)) return "common";
+		if (packageName === this.#localPackage?.name) return "project";
+		const packageMeta = this.#storage.get(packageName);
+		if (!packageMeta) return null;
+		if (packageMeta.importUrl === `/node_modules/${packageName}`) return "local-install";
+		return "registry-install";
+	}
+	async addPackage(packageName) {
+		const existingPackage = this.#packages.get(packageName);
+		if (existingPackage) return {
+			type: "success",
+			package: existingPackage
+		};
+		try {
+			const packageWithMeta = await this.#loadPackage(packageName);
+			this.#registerPackage(packageWithMeta);
+			return {
+				type: "success",
+				package: packageWithMeta.loadedPackage
+			};
+		} catch (error) {
+			return {
+				type: "error",
+				error: error instanceof Error ? error : new Error(String(error))
+			};
+		}
+	}
+	async addPackages(packageNames) {
+		const results = [];
+		for (const packageName of packageNames) {
+			const result = await this.addPackage(packageName);
+			results.push(result);
+		}
+		return results;
+	}
+	removePackage(name) {
+		this.#packages.delete(name);
+		this.#storage.delete(name);
+		this.#unmountStylesheet(name);
+		this.#notifyPackagesChanged();
+	}
+	subscribe(handler) {
+		this.#subscribers.add(handler);
+		return () => {
+			this.#subscribers.delete(handler);
+		};
+	}
+	load(documentType) {
+		const documentModelModule = Array.from(this.#packages.values().flatMap((p) => p.modules.documentModelModules ?? [])).find((m) => m.documentType === documentType);
+		if (documentModelModule) return Promise.resolve(documentModelModule);
+		return Promise.reject(/* @__PURE__ */ new Error("Model not available"));
+	}
+	#loadCommonPackage() {
+		const documentModelDocumentModelModule = loadDocumentModelDocumentModelModule();
+		const driveDocumentModelModule = loadDriveDocumentModelModule();
+		const documentModelEditorModule = loadDocumentModelEditor();
+		const genericDriveExplorerEditorModule = loadGenericDriveExplorerEditorModule();
+		const name = COMMON_PACKAGE_NAME;
+		return {
+			name,
+			importUrl: null,
+			stylesheetUrl: null,
+			loadedPackage: {
+				id: COMMON_PACKAGE_ID,
+				name,
+				description: "Common",
+				category: "Common",
+				author: {
+					name: "Powerhouse",
+					website: "https://powerhousedao.com"
+				},
+				modules: {
+					documentModelModules: [documentModelDocumentModelModule, driveDocumentModelModule],
+					editorModules: [documentModelEditorModule, genericDriveExplorerEditorModule]
+				},
+				upgradeManifests: []
+			}
+		};
+	}
+	#loadVetraPackage() {
+		return {
+			name: vetraVetraPackage.manifest.name,
+			importUrl: null,
+			stylesheetUrl: null,
+			loadedPackage: convertLegacyLibToVetraPackage(vetraVetraPackage)
+		};
+	}
+	async #loadPackageFromNodeModules(name) {
+		const importUrl = `/node_modules/${name}/browser/index.js`;
+		const stylesheetUrl = `/node_modules/${name}/style.css`;
+		return await this.#importPackage({
+			name,
+			importUrl,
+			stylesheetUrl
+		});
+	}
+	async #loadPackageFromRegistry(name) {
+		const importUrl = `${this.#cdnUrl}/${name}/browser/index.js`;
+		const stylesheetUrl = `${this.#cdnUrl}/${name}/style.css`;
+		return await this.#importPackage({
+			name,
+			importUrl,
+			stylesheetUrl
+		});
+	}
+	async #importPackage(packageMeta) {
+		const { name, importUrl, stylesheetUrl } = packageMeta;
+		if (!importUrl) throw new Error(`Import url not defined for package "${name}".`);
+		return {
+			name,
+			loadedPackage: convertLegacyLibToVetraPackage(await import(
+				/* @vite-ignore */
+				importUrl
+)),
+			importUrl,
+			stylesheetUrl
+		};
+	}
+	async #loadPackage(packageName) {
+		if (LOCAL_PACKAGES.includes(packageName)) throw new Error(`Package "${packageName}" is a local package and cannot be loaded dynamically.`);
+		if (!import.meta.env.PROD) try {
+			return await this.#loadPackageFromNodeModules(packageName);
+		} catch (error) {
+			console.warn(`Failed to load package "${packageName}" from node_modules:`, error);
+		}
+		if (!this.registryUrl) throw new Error("Registry url not defined.");
+		return await this.#loadPackageFromRegistry(packageName);
+	}
+	#registerPackage(packageWithMeta) {
+		const { name, loadedPackage, importUrl, stylesheetUrl } = packageWithMeta;
+		if (stylesheetUrl !== null) this.#mountStylesheet(name, stylesheetUrl);
+		this.#packages.set(name, loadedPackage);
+		this.#storage.set(name, {
+			name,
+			importUrl,
+			stylesheetUrl
+		});
+		this.#notifyPackagesChanged();
+	}
+	#mountStylesheet(name, href) {
+		const existing = this.#stylesheets.get(name);
+		if (existing) return existing;
+		const link = document.createElement("link");
+		link.rel = "stylesheet";
+		link.href = href;
+		document.head.appendChild(link);
+		this.#stylesheets.set(name, link);
+	}
+	#unmountStylesheet(name) {
+		const link = this.#stylesheets.get(name);
+		if (!link) return;
+		link.remove();
+		this.#stylesheets.delete(name);
+	}
+	#notifyPackagesChanged() {
+		this.#packagesMemo = Array.from(this.#packages.values());
+		const packages = this.packages;
+		this.#subscribers.forEach((handler) => {
+			handler({ packages });
+		});
+	}
+};
+//#endregion
+//#region src/packages.config.ts
+function assertPackagesConfig(value) {
+	if (typeof value !== "object" || value === null) throw new Error("ph-packages.json must be a JSON object");
+	const obj = value;
+	if (!Array.isArray(obj.packages)) throw new Error("ph-packages.json: 'packages' must be an array");
+	if (!obj.packages.every((item) => typeof item === "string")) throw new Error("ph-packages.json: 'packages' must be an array of strings");
+}
+let cached;
+async function loadPackagesConfig() {
+	if (cached) return cached;
+	const url = `${import.meta.env.BASE_URL ?? "/"}ph-packages.json`;
+	const json = await (await fetch(url)).json();
+	assertPackagesConfig(json);
+	cached = json;
+	return cached;
+}
+//#endregion
+//#region src/pglite.db.ts
+async function getDb() {
+	const worker = new Worker(new URL("./pglite.worker.js", import.meta.url), { type: "module" });
+	const pgLite = await PGliteWorker.create(worker, { extensions: { live } });
+	return {
+		pgLite,
+		relationalDb: createRelationalDb(new Kysely({ dialect: new PGliteDialect(pgLite) }))
+	};
+}
+//#endregion
+//#region src/store/processor-host-module.ts
+async function createProcessorHostModule() {
+	try {
+		const { pgLite, relationalDb } = await getDb();
+		const { store: analyticsStore } = await createAnalyticsStore({ pgLite });
+		return {
+			relationalDb,
+			analyticsStore,
+			processorApp: "connect"
+		};
+	} catch (error) {
+		console.error(`Failed to initialize processor host module:`);
+		console.error(error);
+	}
+}
+//#endregion
+//#region src/store/reactor.ts
+async function clearReactorStorage() {
+	const pg = window.ph?.reactorClientModule?.pg;
+	if (!pg) throw new Error("PGlite not found");
+	await dropAllReactorStorage(pg);
+	await pg.close();
+}
+async function createReactor(localPackage) {
+	if (!window.ph) window.ph = {};
+	if (window.ph.loading) return;
+	window.ph.loading = true;
+	addPHEventHandlers();
+	setPHToast(toast);
+	const features = await initFeatureFlags();
+	logger.info("Features: @features", JSON.stringify(Object.fromEntries(features), null, 2));
+	const keyPairStorage = await BrowserKeyStorage.create();
+	const renownCrypto = await new RenownCryptoBuilder().withKeyPairStorage(keyPairStorage).build();
+	const renown = await new RenownBuilder("connect", {
+		basename: phGlobalConfigFromEnv.routerBasename,
+		baseUrl: phGlobalConfigFromEnv.renownUrl
+	}).withCrypto(renownCrypto).build();
+	const packagesConfig = await loadPackagesConfig();
+	const packageManager = new BrowserPackageManager(phGlobalConfigFromEnv.routerBasename ?? "", PH_PACKAGE_REGISTRY_URL);
+	setVetraPackageManager(packageManager);
+	await packageManager.init(localPackage);
+	(await packageManager.addPackages(packagesConfig.packages)).map((r) => {
+		if (r.type === "error") console.error(r.error);
+	});
+	const reactorClientModule = await createBrowserReactor(packageManager.packages.flatMap((pkg) => pkg.modules.documentModelModules).filter((module, index, modules) => module !== void 0 && modules.findIndex((m) => m?.documentType === module.documentType && m.version === module.version) === index).filter((d) => d !== void 0), packageManager.packages.flatMap((pkg) => pkg.upgradeManifests).filter((u) => u !== void 0), renown);
+	const drives = await getDrives(reactorClientModule.client);
+	const path = window.location.pathname;
+	const driveSlug = extractDriveSlugFromPath(path);
+	const nodeSlug = extractNodeSlugFromPath(path);
+	await login(getDidFromUrl(), renown);
+	const documentCache = new DocumentCache(reactorClientModule.client);
+	setDefaultPHGlobalConfig(phGlobalConfigFromEnv);
+	setReactorClientModule(reactorClientModule);
+	setReactorClient(reactorClientModule.client);
+	setDocumentCache(documentCache);
+	setRenown(renown);
+	setDrives(drives);
+	setSelectedDrive(driveSlug);
+	setSelectedNode(nodeSlug);
+	setFeatures(features);
+	const defaultDrivesConfig = getDefaultDrivesFromEnv();
+	if (defaultDrivesConfig.length > 0) await addDefaultDrivesForNewReactor(defaultDrivesConfig);
+	const remoteUrl = getDriveUrl();
+	if (remoteUrl) try {
+		await addRemoteDrive(remoteUrl);
+	} catch (error) {
+		console.error(`Failed to add remote drive from ${remoteUrl}:`, error);
+	}
+	const reactorClient = reactorClientModule.client;
+	reactorClient.subscribe({ type: "powerhouse/document-drive" }, (event) => {
+		logger.verbose("ReactorClient subscription event: @event", event);
+		refreshReactorDataClient(reactorClientModule.client).catch((e) => logger.error("@error", e));
+	});
+	reactorClient.subscribe({}, (event) => {
+		if (event.type !== DocumentChangeType.Deleted) return;
+		const deletedId = event.context?.childId;
+		if (!deletedId) return;
+		const selectedDriveId = window.ph?.selectedDriveId;
+		const selectedNodeId = window.ph?.selectedNodeId;
+		if (selectedDriveId && deletedId === selectedDriveId) {
+			setSelectedDrive(void 0);
+			toast("The drive you were viewing has been deleted");
+			return;
+		}
+		if (selectedNodeId && deletedId === selectedNodeId) {
+			setSelectedNode(void 0);
+			toast("The document you were editing has been deleted");
+		}
+	});
+	await refreshReactorDataClient(reactorClientModule.client);
+	const packagesWithProcessorFactories = packageManager.packages.filter((pkg) => pkg.processorFactory !== void 0);
+	if (packagesWithProcessorFactories.length > 0) {
+		const processorHostModule = await createProcessorHostModule();
+		if (processorHostModule !== void 0) await Promise.all(packagesWithProcessorFactories.map(async (pkg) => {
+			const { id, name, processorFactory } = pkg;
+			logger.info("Loading processor factory: @name", name);
+			try {
+				const factory = await processorFactory(processorHostModule);
+				await reactorClientModule.reactorModule?.processorManager.registerFactory(id, factory);
+			} catch (error) {
+				logger.error(`Error registering processor: @name`, name);
+				logger.error("@error", error);
+			}
+		}));
+	}
+	window.ph.loading = false;
+}
+function getDidFromUrl() {
+	const didComponent = new URLSearchParams(window.location.search).get("user");
+	return didComponent ? decodeURIComponent(didComponent) : void 0;
+}
+function getDriveUrl() {
+	const driveUrl = new URLSearchParams(window.location.search).get("driveUrl");
+	return driveUrl ? decodeURIComponent(driveUrl) : void 0;
+}
+//#endregion
+export { createReactor as n, clearReactorStorage as t };
+
+//# sourceMappingURL=reactor-Be0fd4-f.js.map