@ox-content/islands 3.1.3 → 3.1.5

package/dist/html-host.cjs

@@ -0,0 +1,8 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_html_host = require("./html-host2.cjs");
+exports.HtmlHostClientHydrationError = require_html_host.HtmlHostClientHydrationError;
+exports.createHtmlHostClientError = require_html_host.createHtmlHostClientError;
+exports.createHtmlHostLazyHydrate = require_html_host.createHtmlHostLazyHydrate;
+exports.initHtmlHost = require_html_host.initHtmlHost;
+exports.readHtmlHostSlot = require_html_host.readHtmlHostSlot;
+exports.reportHtmlHostClientError = require_html_host.reportHtmlHostClientError;

package/dist/html-host.d.cts

@@ -0,0 +1,88 @@
+import { n as HydrateFunction, r as InitIslandsOptions } from "./types.cjs";
+//#region src/html-host-errors.d.ts
+type HtmlHostClientDiagnosticCode = "missing-island-name" | "missing-module-id" | "unknown-module" | "module-load-failed" | "runtime-load-failed" | "missing-export" | "render-failed";
+interface HtmlHostClientError {
+  code: HtmlHostClientDiagnosticCode;
+  message: string;
+  element: HTMLElement;
+  props: Record<string, unknown>;
+  componentName?: string;
+  moduleId?: string;
+  exportName?: string;
+  cause?: unknown;
+}
+declare class HtmlHostClientHydrationError extends Error {
+  readonly diagnostic: HtmlHostClientError;
+  constructor(diagnostic: HtmlHostClientError);
+}
+interface HtmlHostClientErrorContext {
+  componentName?: string;
+  moduleId?: string;
+  exportName?: string;
+  cause?: unknown;
+  frameworkName?: string;
+}
+declare function reportHtmlHostClientError(input: {
+  onError?: (error: HtmlHostClientError) => void;
+}, error: HtmlHostClientError, eventName?: string): void;
+declare function createHtmlHostClientError(code: HtmlHostClientDiagnosticCode, element: HTMLElement, props: Record<string, unknown>, context?: HtmlHostClientErrorContext): HtmlHostClientError;
+//#endregion
+//#region src/html-host.d.ts
+type HtmlHostClientComponentValue = unknown;
+type HtmlHostClientModuleValue = unknown;
+type HtmlHostClientModuleLoader<TModule = HtmlHostClientModuleValue> = () => TModule | PromiseLike<TModule>;
+type HtmlHostClientModules<TModule = HtmlHostClientModuleValue> = Readonly<Record<string, HtmlHostClientModuleLoader<TModule>>> | ReadonlyMap<string, HtmlHostClientModuleLoader<TModule>>;
+interface HtmlHostClientContext<TRuntime = undefined> {
+  component: unknown;
+  componentName: string;
+  element: HTMLElement;
+  exportName: string;
+  moduleExports: unknown;
+  moduleId: string;
+  props: Record<string, unknown>;
+  runtime: TRuntime | undefined;
+  slotHtml: string | undefined;
+}
+type HtmlHostClientRenderer<TRuntime = undefined> = (context: HtmlHostClientContext<TRuntime>) => void | (() => void) | PromiseLike<void | (() => void)>;
+type HtmlHostClientRuntimeLoader<TRuntime = undefined> = () => TRuntime | PromiseLike<TRuntime>;
+type HtmlHostModuleIdResolver = (element: HTMLElement, context: {
+  componentName: string;
+  props: Record<string, unknown>;
+}) => string | undefined;
+type HtmlHostExportNameResolver = (element: HTMLElement, context: {
+  componentName: string;
+  moduleId: string;
+  props: Record<string, unknown>;
+}) => string | undefined;
+interface HtmlHostClientAdapter<TRuntime = undefined> {
+  frameworkName?: string;
+  eventName?: string;
+  render: HtmlHostClientRenderer<TRuntime>;
+  loadRuntime?: HtmlHostClientRuntimeLoader<TRuntime>;
+  preserveElementContents?: boolean;
+}
+interface CreateHtmlHostLazyHydrateInput<TRuntime = undefined> {
+  modules: HtmlHostClientModules;
+  adapter?: HtmlHostClientAdapter<TRuntime>;
+  render?: HtmlHostClientRenderer<TRuntime>;
+  loadRuntime?: HtmlHostClientRuntimeLoader<TRuntime>;
+  preserveElementContents?: boolean;
+  resolveModuleId?: HtmlHostModuleIdResolver;
+  resolveExportName?: HtmlHostExportNameResolver;
+  onError?: (error: HtmlHostClientError) => void;
+  frameworkName?: string;
+  eventName?: string;
+}
+type HtmlHostHydrationHandle = (() => void) & PromiseLike<void>;
+type HtmlHostLazyHydrateFunction = (element: HTMLElement, props: Record<string, unknown>) => HtmlHostHydrationHandle;
+type HtmlHostInitIslands<TController = unknown> = (hydrate: HydrateFunction, options?: InitIslandsOptions) => TController;
+type InitHtmlHostInput<TRuntime = undefined> = CreateHtmlHostLazyHydrateInput<TRuntime> & {
+  initIslands: HtmlHostInitIslands;
+  options?: InitIslandsOptions;
+};
+declare function initHtmlHost<TRuntime = undefined>(input: InitHtmlHostInput<TRuntime>): ReturnType<InitHtmlHostInput<TRuntime>["initIslands"]>;
+declare function createHtmlHostLazyHydrate<TRuntime = undefined>(input: CreateHtmlHostLazyHydrateInput<TRuntime>): HtmlHostLazyHydrateFunction;
+declare function readHtmlHostSlot(element: Pick<HTMLElement, "dataset" | "innerHTML">): string | undefined;
+//#endregion
+export { HtmlHostClientHydrationError, createHtmlHostClientError, createHtmlHostLazyHydrate, initHtmlHost, readHtmlHostSlot, reportHtmlHostClientError };
+export type { CreateHtmlHostLazyHydrateInput, HtmlHostClientAdapter, HtmlHostClientComponentValue, HtmlHostClientContext, HtmlHostClientDiagnosticCode, HtmlHostClientError, HtmlHostClientModuleLoader, HtmlHostClientModules, HtmlHostClientModuleValue, HtmlHostClientRenderer, HtmlHostClientRuntimeLoader, HtmlHostExportNameResolver, HtmlHostHydrationHandle, HtmlHostInitIslands, HtmlHostLazyHydrateFunction, HtmlHostModuleIdResolver, InitHtmlHostInput };

package/dist/html-host.d.mts

@@ -0,0 +1,88 @@
+import { n as HydrateFunction, r as InitIslandsOptions } from "./types.mjs";
+//#region src/html-host-errors.d.ts
+type HtmlHostClientDiagnosticCode = "missing-island-name" | "missing-module-id" | "unknown-module" | "module-load-failed" | "runtime-load-failed" | "missing-export" | "render-failed";
+interface HtmlHostClientError {
+  code: HtmlHostClientDiagnosticCode;
+  message: string;
+  element: HTMLElement;
+  props: Record<string, unknown>;
+  componentName?: string;
+  moduleId?: string;
+  exportName?: string;
+  cause?: unknown;
+}
+declare class HtmlHostClientHydrationError extends Error {
+  readonly diagnostic: HtmlHostClientError;
+  constructor(diagnostic: HtmlHostClientError);
+}
+interface HtmlHostClientErrorContext {
+  componentName?: string;
+  moduleId?: string;
+  exportName?: string;
+  cause?: unknown;
+  frameworkName?: string;
+}
+declare function reportHtmlHostClientError(input: {
+  onError?: (error: HtmlHostClientError) => void;
+}, error: HtmlHostClientError, eventName?: string): void;
+declare function createHtmlHostClientError(code: HtmlHostClientDiagnosticCode, element: HTMLElement, props: Record<string, unknown>, context?: HtmlHostClientErrorContext): HtmlHostClientError;
+//#endregion
+//#region src/html-host.d.ts
+type HtmlHostClientComponentValue = unknown;
+type HtmlHostClientModuleValue = unknown;
+type HtmlHostClientModuleLoader<TModule = HtmlHostClientModuleValue> = () => TModule | PromiseLike<TModule>;
+type HtmlHostClientModules<TModule = HtmlHostClientModuleValue> = Readonly<Record<string, HtmlHostClientModuleLoader<TModule>>> | ReadonlyMap<string, HtmlHostClientModuleLoader<TModule>>;
+interface HtmlHostClientContext<TRuntime = undefined> {
+  component: unknown;
+  componentName: string;
+  element: HTMLElement;
+  exportName: string;
+  moduleExports: unknown;
+  moduleId: string;
+  props: Record<string, unknown>;
+  runtime: TRuntime | undefined;
+  slotHtml: string | undefined;
+}
+type HtmlHostClientRenderer<TRuntime = undefined> = (context: HtmlHostClientContext<TRuntime>) => void | (() => void) | PromiseLike<void | (() => void)>;
+type HtmlHostClientRuntimeLoader<TRuntime = undefined> = () => TRuntime | PromiseLike<TRuntime>;
+type HtmlHostModuleIdResolver = (element: HTMLElement, context: {
+  componentName: string;
+  props: Record<string, unknown>;
+}) => string | undefined;
+type HtmlHostExportNameResolver = (element: HTMLElement, context: {
+  componentName: string;
+  moduleId: string;
+  props: Record<string, unknown>;
+}) => string | undefined;
+interface HtmlHostClientAdapter<TRuntime = undefined> {
+  frameworkName?: string;
+  eventName?: string;
+  render: HtmlHostClientRenderer<TRuntime>;
+  loadRuntime?: HtmlHostClientRuntimeLoader<TRuntime>;
+  preserveElementContents?: boolean;
+}
+interface CreateHtmlHostLazyHydrateInput<TRuntime = undefined> {
+  modules: HtmlHostClientModules;
+  adapter?: HtmlHostClientAdapter<TRuntime>;
+  render?: HtmlHostClientRenderer<TRuntime>;
+  loadRuntime?: HtmlHostClientRuntimeLoader<TRuntime>;
+  preserveElementContents?: boolean;
+  resolveModuleId?: HtmlHostModuleIdResolver;
+  resolveExportName?: HtmlHostExportNameResolver;
+  onError?: (error: HtmlHostClientError) => void;
+  frameworkName?: string;
+  eventName?: string;
+}
+type HtmlHostHydrationHandle = (() => void) & PromiseLike<void>;
+type HtmlHostLazyHydrateFunction = (element: HTMLElement, props: Record<string, unknown>) => HtmlHostHydrationHandle;
+type HtmlHostInitIslands<TController = unknown> = (hydrate: HydrateFunction, options?: InitIslandsOptions) => TController;
+type InitHtmlHostInput<TRuntime = undefined> = CreateHtmlHostLazyHydrateInput<TRuntime> & {
+  initIslands: HtmlHostInitIslands;
+  options?: InitIslandsOptions;
+};
+declare function initHtmlHost<TRuntime = undefined>(input: InitHtmlHostInput<TRuntime>): ReturnType<InitHtmlHostInput<TRuntime>["initIslands"]>;
+declare function createHtmlHostLazyHydrate<TRuntime = undefined>(input: CreateHtmlHostLazyHydrateInput<TRuntime>): HtmlHostLazyHydrateFunction;
+declare function readHtmlHostSlot(element: Pick<HTMLElement, "dataset" | "innerHTML">): string | undefined;
+//#endregion
+export { HtmlHostClientHydrationError, createHtmlHostClientError, createHtmlHostLazyHydrate, initHtmlHost, readHtmlHostSlot, reportHtmlHostClientError };
+export type { CreateHtmlHostLazyHydrateInput, HtmlHostClientAdapter, HtmlHostClientComponentValue, HtmlHostClientContext, HtmlHostClientDiagnosticCode, HtmlHostClientError, HtmlHostClientModuleLoader, HtmlHostClientModules, HtmlHostClientModuleValue, HtmlHostClientRenderer, HtmlHostClientRuntimeLoader, HtmlHostExportNameResolver, HtmlHostHydrationHandle, HtmlHostInitIslands, HtmlHostLazyHydrateFunction, HtmlHostModuleIdResolver, InitHtmlHostInput };

package/dist/html-host.mjs

@@ -0,0 +1,2 @@
+import { a as createHtmlHostClientError, i as HtmlHostClientHydrationError, n as initHtmlHost, o as reportHtmlHostClientError, r as readHtmlHostSlot, t as createHtmlHostLazyHydrate } from "./html-host2.mjs";
+export { HtmlHostClientHydrationError, createHtmlHostClientError, createHtmlHostLazyHydrate, initHtmlHost, readHtmlHostSlot, reportHtmlHostClientError };

package/dist/html-host2.cjs

@@ -0,0 +1,259 @@
+//#region src/html-host-errors.ts
+var HtmlHostClientHydrationError = class extends Error {
+	diagnostic;
+	constructor(diagnostic) {
+		super(diagnostic.message);
+		this.name = "HtmlHostClientHydrationError";
+		this.diagnostic = diagnostic;
+	}
+};
+function reportHtmlHostClientError(input, error, eventName = "ox-content-html-host:error") {
+	error.element.classList?.add("ox-island-error");
+	error.element.dataset.oxError = error.message;
+	input.onError?.(error);
+	if (typeof CustomEvent === "function" && typeof error.element.dispatchEvent === "function") error.element.dispatchEvent(new CustomEvent(eventName, { detail: error }));
+}
+function createHtmlHostClientError(code, element, props, context = {}) {
+	return {
+		code,
+		element,
+		props,
+		componentName: context.componentName,
+		moduleId: context.moduleId,
+		exportName: context.exportName,
+		cause: context.cause,
+		message: clientErrorMessage(code, context)
+	};
+}
+function once(cleanup) {
+	let called = false;
+	return () => {
+		if (called) return;
+		called = true;
+		cleanup();
+	};
+}
+function clientErrorMessage(code, context) {
+	const framework = context.frameworkName?.trim() || "HTML host";
+	const island = `${framework} island`;
+	const component = context.componentName ? `${island} "${context.componentName}"` : island;
+	const reason = causeMessage(context.cause);
+	switch (code) {
+		case "missing-island-name": return `${island} element is missing data-ox-island.`;
+		case "missing-module-id": return `${component} is missing data-ox-module.`;
+		case "unknown-module": return `${component} references unknown module "${context.moduleId ?? ""}".`;
+		case "module-load-failed": return `${component} module "${context.moduleId ?? ""}" failed to load: ${reason}`;
+		case "runtime-load-failed": return `${framework} runtime failed to load: ${reason}`;
+		case "missing-export": return `${component} module "${context.moduleId ?? ""}" is missing export "${context.exportName ?? "default"}".`;
+		case "render-failed": return `${component} failed to render: ${reason}`;
+	}
+}
+function causeMessage(cause) {
+	if (cause == null) return "";
+	if (cause instanceof Error) return cause.message;
+	if (typeof cause === "string") return cause;
+	if (typeof cause === "number" || typeof cause === "boolean") return cause.toString();
+	try {
+		return JSON.stringify(cause);
+	} catch {
+		return Object.prototype.toString.call(cause);
+	}
+}
+//#endregion
+//#region src/html-host.ts
+const ISLAND_JSON_SCRIPT = /^\s*<script type="application\/json">[\s\S]*?<\/script>/;
+function initHtmlHost(input) {
+	return input.initIslands(createHtmlHostLazyHydrate(input), input.options);
+}
+function createHtmlHostLazyHydrate(input) {
+	const render = resolveRenderer(input);
+	const loadRuntime = input.loadRuntime ?? input.adapter?.loadRuntime;
+	const preserveElementContents = input.preserveElementContents ?? input.adapter?.preserveElementContents ?? false;
+	const frameworkName = input.frameworkName ?? input.adapter?.frameworkName ?? "HTML host";
+	const eventName = input.eventName ?? input.adapter?.eventName ?? "ox-content-html-host:error";
+	const moduleCache = /* @__PURE__ */ new Map();
+	let runtimeCache;
+	return (element, props) => {
+		let disposed = false;
+		let disposeMounted;
+		const dispose = (() => {
+			if (disposed) return;
+			disposed = true;
+			disposeMounted?.();
+			disposeMounted = void 0;
+		});
+		const ready = (async () => {
+			const componentName = element.dataset.oxIsland;
+			if (!componentName) fail(input, eventName, frameworkName, "missing-island-name", element, props);
+			const moduleId = input.resolveModuleId?.(element, {
+				componentName,
+				props
+			}) ?? element.dataset.oxModule;
+			if (!moduleId) fail(input, eventName, frameworkName, "missing-module-id", element, props, { componentName });
+			if (!moduleLoader(input.modules, moduleId)) fail(input, eventName, frameworkName, "unknown-module", element, props, {
+				componentName,
+				moduleId
+			});
+			const exportName = input.resolveExportName?.(element, {
+				componentName,
+				moduleId,
+				props
+			}) ?? element.dataset.oxExport ?? "default";
+			const slotHtml = readHtmlHostSlot(element);
+			let moduleExports;
+			let runtime;
+			try {
+				moduleExports = await loadClientModule(input.modules, moduleId, moduleCache);
+			} catch (cause) {
+				if (!disposed) fail(input, eventName, frameworkName, "module-load-failed", element, props, {
+					componentName,
+					moduleId,
+					exportName,
+					cause
+				});
+				return;
+			}
+			if (disposed) return;
+			try {
+				runtime = await loadHtmlHostRuntime(loadRuntime, () => runtimeCache, (pending) => {
+					runtimeCache = pending;
+				});
+			} catch (cause) {
+				if (!disposed) fail(input, eventName, frameworkName, "runtime-load-failed", element, props, {
+					componentName,
+					moduleId,
+					exportName,
+					cause
+				});
+				return;
+			}
+			if (disposed) return;
+			const component = exportedValue(moduleExports, exportName);
+			if (component == null) fail(input, eventName, frameworkName, "missing-export", element, props, {
+				componentName,
+				moduleId,
+				exportName,
+				cause: /* @__PURE__ */ new Error(`Export "${exportName}" was not found.`)
+			});
+			if (!preserveElementContents) element.innerHTML = "";
+			try {
+				const cleanup = await render({
+					component,
+					componentName,
+					element,
+					exportName,
+					moduleExports,
+					moduleId,
+					props,
+					runtime,
+					slotHtml
+				});
+				disposeMounted = cleanup ? once(cleanup) : void 0;
+				if (disposed) {
+					disposeMounted?.();
+					disposeMounted = void 0;
+				}
+			} catch (cause) {
+				if (!disposed) fail(input, eventName, frameworkName, "render-failed", element, props, {
+					componentName,
+					moduleId,
+					exportName,
+					cause
+				});
+			}
+		})();
+		ready.catch(() => void 0);
+		Object.defineProperty(dispose, "then", { value: ready.then.bind(ready) });
+		return dispose;
+	};
+}
+function readHtmlHostSlot(element) {
+	const fromAttr = element.dataset.oxContent;
+	if (fromAttr) return fromAttr;
+	if (element.dataset.oxSsr === "true") return void 0;
+	return element.innerHTML.replace(ISLAND_JSON_SCRIPT, "") || void 0;
+}
+async function loadClientModule(modules, moduleId, cache) {
+	const cached = cache.get(moduleId);
+	if (cached) return cached;
+	const loader = moduleLoader(modules, moduleId);
+	if (!loader) throw new Error(`Unknown module "${moduleId}".`);
+	const pending = Promise.resolve().then(loader).catch((cause) => {
+		cache.delete(moduleId);
+		throw cause;
+	});
+	cache.set(moduleId, pending);
+	return pending;
+}
+async function loadHtmlHostRuntime(load, getCached, setCached) {
+	if (!load) return void 0;
+	const cached = getCached();
+	if (cached) return cached;
+	const pending = Promise.resolve().then(load).catch((cause) => {
+		setCached(void 0);
+		throw cause;
+	});
+	setCached(pending);
+	return pending;
+}
+function fail(input, eventName, frameworkName, code, element, props, context = {}) {
+	const error = createHtmlHostClientError(code, element, props, {
+		...context,
+		frameworkName
+	});
+	reportHtmlHostClientError(input, error, eventName);
+	throw new HtmlHostClientHydrationError(error);
+}
+function resolveRenderer(input) {
+	const render = input.render ?? input.adapter?.render;
+	if (render) return render;
+	throw new Error("initHtmlHost requires either render or adapter.render.");
+}
+function moduleLoader(modules, moduleId) {
+	return isReadonlyMap(modules) ? modules.get(moduleId) : modules[moduleId];
+}
+function isReadonlyMap(value) {
+	return typeof value.get === "function";
+}
+function exportedValue(moduleExports, exportName) {
+	if (exportName === "default" && typeof moduleExports === "function") return moduleExports;
+	if (!moduleExports || typeof moduleExports !== "object") return;
+	return moduleExports[exportName];
+}
+//#endregion
+Object.defineProperty(exports, "HtmlHostClientHydrationError", {
+	enumerable: true,
+	get: function() {
+		return HtmlHostClientHydrationError;
+	}
+});
+Object.defineProperty(exports, "createHtmlHostClientError", {
+	enumerable: true,
+	get: function() {
+		return createHtmlHostClientError;
+	}
+});
+Object.defineProperty(exports, "createHtmlHostLazyHydrate", {
+	enumerable: true,
+	get: function() {
+		return createHtmlHostLazyHydrate;
+	}
+});
+Object.defineProperty(exports, "initHtmlHost", {
+	enumerable: true,
+	get: function() {
+		return initHtmlHost;
+	}
+});
+Object.defineProperty(exports, "readHtmlHostSlot", {
+	enumerable: true,
+	get: function() {
+		return readHtmlHostSlot;
+	}
+});
+Object.defineProperty(exports, "reportHtmlHostClientError", {
+	enumerable: true,
+	get: function() {
+		return reportHtmlHostClientError;
+	}
+});

package/dist/html-host2.d.cts

@@ -0,0 +1,2 @@
+import { C as reportHtmlHostClientError, S as createHtmlHostClientError, _ as initHtmlHost, a as HtmlHostClientModuleLoader, b as HtmlHostClientError, c as HtmlHostClientRenderer, d as HtmlHostHydrationHandle, f as HtmlHostInitIslands, g as createHtmlHostLazyHydrate, h as InitHtmlHostInput, i as HtmlHostClientContext, l as HtmlHostClientRuntimeLoader, m as HtmlHostModuleIdResolver, n as HtmlHostClientAdapter, o as HtmlHostClientModuleValue, p as HtmlHostLazyHydrateFunction, r as HtmlHostClientComponentValue, s as HtmlHostClientModules, t as CreateHtmlHostLazyHydrateInput, u as HtmlHostExportNameResolver, v as readHtmlHostSlot, x as HtmlHostClientHydrationError, y as HtmlHostClientDiagnosticCode } from "./html-host.cjs";
+export { CreateHtmlHostLazyHydrateInput, HtmlHostClientAdapter, HtmlHostClientComponentValue, HtmlHostClientContext, type HtmlHostClientDiagnosticCode, type HtmlHostClientError, HtmlHostClientHydrationError, HtmlHostClientModuleLoader, HtmlHostClientModuleValue, HtmlHostClientModules, HtmlHostClientRenderer, HtmlHostClientRuntimeLoader, HtmlHostExportNameResolver, HtmlHostHydrationHandle, HtmlHostInitIslands, HtmlHostLazyHydrateFunction, HtmlHostModuleIdResolver, InitHtmlHostInput, createHtmlHostClientError, createHtmlHostLazyHydrate, initHtmlHost, readHtmlHostSlot, reportHtmlHostClientError };

package/dist/html-host2.d.mts

@@ -0,0 +1,2 @@
+import { C as reportHtmlHostClientError, S as createHtmlHostClientError, _ as initHtmlHost, a as HtmlHostClientModuleLoader, b as HtmlHostClientError, c as HtmlHostClientRenderer, d as HtmlHostHydrationHandle, f as HtmlHostInitIslands, g as createHtmlHostLazyHydrate, h as InitHtmlHostInput, i as HtmlHostClientContext, l as HtmlHostClientRuntimeLoader, m as HtmlHostModuleIdResolver, n as HtmlHostClientAdapter, o as HtmlHostClientModuleValue, p as HtmlHostLazyHydrateFunction, r as HtmlHostClientComponentValue, s as HtmlHostClientModules, t as CreateHtmlHostLazyHydrateInput, u as HtmlHostExportNameResolver, v as readHtmlHostSlot, x as HtmlHostClientHydrationError, y as HtmlHostClientDiagnosticCode } from "./html-host.mjs";
+export { CreateHtmlHostLazyHydrateInput, HtmlHostClientAdapter, HtmlHostClientComponentValue, HtmlHostClientContext, type HtmlHostClientDiagnosticCode, type HtmlHostClientError, HtmlHostClientHydrationError, HtmlHostClientModuleLoader, HtmlHostClientModuleValue, HtmlHostClientModules, HtmlHostClientRenderer, HtmlHostClientRuntimeLoader, HtmlHostExportNameResolver, HtmlHostHydrationHandle, HtmlHostInitIslands, HtmlHostLazyHydrateFunction, HtmlHostModuleIdResolver, InitHtmlHostInput, createHtmlHostClientError, createHtmlHostLazyHydrate, initHtmlHost, readHtmlHostSlot, reportHtmlHostClientError };

package/dist/html-host2.mjs

@@ -0,0 +1,226 @@
+//#region src/html-host-errors.ts
+var HtmlHostClientHydrationError = class extends Error {
+	diagnostic;
+	constructor(diagnostic) {
+		super(diagnostic.message);
+		this.name = "HtmlHostClientHydrationError";
+		this.diagnostic = diagnostic;
+	}
+};
+function reportHtmlHostClientError(input, error, eventName = "ox-content-html-host:error") {
+	error.element.classList?.add("ox-island-error");
+	error.element.dataset.oxError = error.message;
+	input.onError?.(error);
+	if (typeof CustomEvent === "function" && typeof error.element.dispatchEvent === "function") error.element.dispatchEvent(new CustomEvent(eventName, { detail: error }));
+}
+function createHtmlHostClientError(code, element, props, context = {}) {
+	return {
+		code,
+		element,
+		props,
+		componentName: context.componentName,
+		moduleId: context.moduleId,
+		exportName: context.exportName,
+		cause: context.cause,
+		message: clientErrorMessage(code, context)
+	};
+}
+function once(cleanup) {
+	let called = false;
+	return () => {
+		if (called) return;
+		called = true;
+		cleanup();
+	};
+}
+function clientErrorMessage(code, context) {
+	const framework = context.frameworkName?.trim() || "HTML host";
+	const island = `${framework} island`;
+	const component = context.componentName ? `${island} "${context.componentName}"` : island;
+	const reason = causeMessage(context.cause);
+	switch (code) {
+		case "missing-island-name": return `${island} element is missing data-ox-island.`;
+		case "missing-module-id": return `${component} is missing data-ox-module.`;
+		case "unknown-module": return `${component} references unknown module "${context.moduleId ?? ""}".`;
+		case "module-load-failed": return `${component} module "${context.moduleId ?? ""}" failed to load: ${reason}`;
+		case "runtime-load-failed": return `${framework} runtime failed to load: ${reason}`;
+		case "missing-export": return `${component} module "${context.moduleId ?? ""}" is missing export "${context.exportName ?? "default"}".`;
+		case "render-failed": return `${component} failed to render: ${reason}`;
+	}
+}
+function causeMessage(cause) {
+	if (cause == null) return "";
+	if (cause instanceof Error) return cause.message;
+	if (typeof cause === "string") return cause;
+	if (typeof cause === "number" || typeof cause === "boolean") return cause.toString();
+	try {
+		return JSON.stringify(cause);
+	} catch {
+		return Object.prototype.toString.call(cause);
+	}
+}
+//#endregion
+//#region src/html-host.ts
+const ISLAND_JSON_SCRIPT = /^\s*<script type="application\/json">[\s\S]*?<\/script>/;
+function initHtmlHost(input) {
+	return input.initIslands(createHtmlHostLazyHydrate(input), input.options);
+}
+function createHtmlHostLazyHydrate(input) {
+	const render = resolveRenderer(input);
+	const loadRuntime = input.loadRuntime ?? input.adapter?.loadRuntime;
+	const preserveElementContents = input.preserveElementContents ?? input.adapter?.preserveElementContents ?? false;
+	const frameworkName = input.frameworkName ?? input.adapter?.frameworkName ?? "HTML host";
+	const eventName = input.eventName ?? input.adapter?.eventName ?? "ox-content-html-host:error";
+	const moduleCache = /* @__PURE__ */ new Map();
+	let runtimeCache;
+	return (element, props) => {
+		let disposed = false;
+		let disposeMounted;
+		const dispose = (() => {
+			if (disposed) return;
+			disposed = true;
+			disposeMounted?.();
+			disposeMounted = void 0;
+		});
+		const ready = (async () => {
+			const componentName = element.dataset.oxIsland;
+			if (!componentName) fail(input, eventName, frameworkName, "missing-island-name", element, props);
+			const moduleId = input.resolveModuleId?.(element, {
+				componentName,
+				props
+			}) ?? element.dataset.oxModule;
+			if (!moduleId) fail(input, eventName, frameworkName, "missing-module-id", element, props, { componentName });
+			if (!moduleLoader(input.modules, moduleId)) fail(input, eventName, frameworkName, "unknown-module", element, props, {
+				componentName,
+				moduleId
+			});
+			const exportName = input.resolveExportName?.(element, {
+				componentName,
+				moduleId,
+				props
+			}) ?? element.dataset.oxExport ?? "default";
+			const slotHtml = readHtmlHostSlot(element);
+			let moduleExports;
+			let runtime;
+			try {
+				moduleExports = await loadClientModule(input.modules, moduleId, moduleCache);
+			} catch (cause) {
+				if (!disposed) fail(input, eventName, frameworkName, "module-load-failed", element, props, {
+					componentName,
+					moduleId,
+					exportName,
+					cause
+				});
+				return;
+			}
+			if (disposed) return;
+			try {
+				runtime = await loadHtmlHostRuntime(loadRuntime, () => runtimeCache, (pending) => {
+					runtimeCache = pending;
+				});
+			} catch (cause) {
+				if (!disposed) fail(input, eventName, frameworkName, "runtime-load-failed", element, props, {
+					componentName,
+					moduleId,
+					exportName,
+					cause
+				});
+				return;
+			}
+			if (disposed) return;
+			const component = exportedValue(moduleExports, exportName);
+			if (component == null) fail(input, eventName, frameworkName, "missing-export", element, props, {
+				componentName,
+				moduleId,
+				exportName,
+				cause: /* @__PURE__ */ new Error(`Export "${exportName}" was not found.`)
+			});
+			if (!preserveElementContents) element.innerHTML = "";
+			try {
+				const cleanup = await render({
+					component,
+					componentName,
+					element,
+					exportName,
+					moduleExports,
+					moduleId,
+					props,
+					runtime,
+					slotHtml
+				});
+				disposeMounted = cleanup ? once(cleanup) : void 0;
+				if (disposed) {
+					disposeMounted?.();
+					disposeMounted = void 0;
+				}
+			} catch (cause) {
+				if (!disposed) fail(input, eventName, frameworkName, "render-failed", element, props, {
+					componentName,
+					moduleId,
+					exportName,
+					cause
+				});
+			}
+		})();
+		ready.catch(() => void 0);
+		Object.defineProperty(dispose, "then", { value: ready.then.bind(ready) });
+		return dispose;
+	};
+}
+function readHtmlHostSlot(element) {
+	const fromAttr = element.dataset.oxContent;
+	if (fromAttr) return fromAttr;
+	if (element.dataset.oxSsr === "true") return void 0;
+	return element.innerHTML.replace(ISLAND_JSON_SCRIPT, "") || void 0;
+}
+async function loadClientModule(modules, moduleId, cache) {
+	const cached = cache.get(moduleId);
+	if (cached) return cached;
+	const loader = moduleLoader(modules, moduleId);
+	if (!loader) throw new Error(`Unknown module "${moduleId}".`);
+	const pending = Promise.resolve().then(loader).catch((cause) => {
+		cache.delete(moduleId);
+		throw cause;
+	});
+	cache.set(moduleId, pending);
+	return pending;
+}
+async function loadHtmlHostRuntime(load, getCached, setCached) {
+	if (!load) return void 0;
+	const cached = getCached();
+	if (cached) return cached;
+	const pending = Promise.resolve().then(load).catch((cause) => {
+		setCached(void 0);
+		throw cause;
+	});
+	setCached(pending);
+	return pending;
+}
+function fail(input, eventName, frameworkName, code, element, props, context = {}) {
+	const error = createHtmlHostClientError(code, element, props, {
+		...context,
+		frameworkName
+	});
+	reportHtmlHostClientError(input, error, eventName);
+	throw new HtmlHostClientHydrationError(error);
+}
+function resolveRenderer(input) {
+	const render = input.render ?? input.adapter?.render;
+	if (render) return render;
+	throw new Error("initHtmlHost requires either render or adapter.render.");
+}
+function moduleLoader(modules, moduleId) {
+	return isReadonlyMap(modules) ? modules.get(moduleId) : modules[moduleId];
+}
+function isReadonlyMap(value) {
+	return typeof value.get === "function";
+}
+function exportedValue(moduleExports, exportName) {
+	if (exportName === "default" && typeof moduleExports === "function") return moduleExports;
+	if (!moduleExports || typeof moduleExports !== "object") return;
+	return moduleExports[exportName];
+}
+//#endregion
+export { createHtmlHostClientError as a, HtmlHostClientHydrationError as i, initHtmlHost as n, reportHtmlHostClientError as o, readHtmlHostSlot as r, createHtmlHostLazyHydrate as t };
+
+//# sourceMappingURL=html-host2.mjs.map