@stratal/inertia-modal 0.0.27 → 0.1.1

package/dist/index.mjs

@@ -1,40 +1,75 @@
+import { a as MODAL_PROP, c as isModalData, i as MODAL_MARKER_HEADER, l as isModalPropPath, n as MODAL_DOCUMENT_HEADER, o as decodeHeldLevels, t as MODAL_BENEATH_PROP } from "./wire-BNVvmku4.mjs";
+import { n as samePath, t as levelPath } from "./level-path-DCJD-aS3.mjs";
+import { I18nModule, withI18n } from "stratal/i18n";
 import { Module } from "stratal/module";
-import { ROUTER_TOKENS, RouterContext } from "stratal/router";
-import { INERTIA_TOKENS } from "@stratal/inertia";
-import { Request as Request$1, inject } from "stratal/di";
+import { ROUTER_TOKENS, RouterContext, markNestedDispatch } from "stratal/router";
+import { Request as Request$1, Transient, inject } from "stratal/di";
 import { HttpException } from "stratal/errors";
+import { INERTIA_TOKENS } from "@stratal/inertia";
 //#region src/tokens.ts
-const MODAL_TOKENS = { ModalService: Symbol.for("stratal:inertia-modal:service") };
+const MODAL_TOKENS = {
+	ModalService: Symbol.for("stratal:inertia-modal:service"),
+	/**
+	* How the page beneath a modal is fetched on a document request. Override it to dispatch through
+	* something other than the app in process.
+	*/
+	BackgroundDispatcher: Symbol.for("stratal:inertia-modal:background-dispatcher")
+};
 //#endregion
 //#region src/augment/router-context.ts
 function augmentRouterContextWithModal(resolveService) {
-	RouterContext.macro("inertiaModal", function(component, props, options) {
+	RouterContext.macro("modal", function(component, props, options) {
 		return resolveService(this).render(this, component, props, options);
 	});
 }
 //#endregion
+//#region src/i18n/en.ts
+const modalMessages = { en: { errors: {
+	backgroundFetchFailed: "Failed to load background page for modal",
+	baseCycle: "The modal base chain leads back to {url}"
+} } };
+//#endregion
 //#region src/errors/modal-background-fetch.error.ts
 /**
-* Thrown when the internal sub-request to fetch the background page fails
-* (e.g., non-2xx response, redirect, or empty body).
+* Thrown when the sub-request for the page beneath a modal answers with something the chain cannot
+* be built from — a non-2xx, a redirect, an empty body, a body that is not a page, or a level of a
+* shape this build cannot read.
+*
+* `cause` carries the parse failure where there was one. The status this reports is a property of
+* the exchange, not of the reason, so every one of those answers the caller identically; a `base`
+* pointing at a route that does not render a page is still a mistake someone has to find, and the
+* reason is the only thing that says which mistake it was.
 *
-* HTTP Status: 502 Bad Gateway — the modal service acted as a proxy and the
-* upstream (background page) returned an unexpected response.
+* HTTP Status: 502 Bad Gateway — this service acted as a proxy and the upstream answered
+* unexpectedly.
 */
 var ModalBackgroundFetchError = class extends HttpException {
-	constructor() {
-		super(502, "Failed to load background page for modal");
+	constructor(cause) {
+		super(502, withI18n("modal.errors.backgroundFetchFailed"), cause);
+	}
+};
+//#endregion
+//#region src/errors/modal-base-cycle.error.ts
+/**
+* Raised when a route's `base` chain leads back to a route already in it.
+*
+* Assembling the chain costs one sub-request per level, so a cycle would otherwise run until the
+* runtime's sub-request budget is exhausted and surface as an opaque failure.
+*/
+var ModalBaseCycleError = class extends HttpException {
+	constructor(url) {
+		super(500, withI18n("modal.errors.baseCycle", { url }));
 	}
 };
 //#endregion
-//#region \0@oxc-project+runtime@0.133.0/helpers/esm/decorateParam.js
+//#region \0@oxc-project+runtime@0.150.0/helpers/esm/decorateParam.js
 function __decorateParam(paramIndex, decorator) {
 	return function(target, key) {
 		decorator(target, key, paramIndex);
 	};
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.133.0/helpers/esm/decorate.js
+//#region \0@oxc-project+runtime@0.150.0/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -42,133 +77,406 @@ function __decorate(decorators, target, key, desc) {
 	return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 //#endregion
-//#region src/services/modal.service.ts
-let ModalService = class ModalService {
+//#region src/server/background.ts
+/**
+* What the marker header carries, minted once and never sent to a client.
+*
+* The answer has to survive every hop between the dispatch and the route — a caching entrypoint
+* re-dispatches the request, and each hop rebuilds it — so it travels in a header, the only thing
+* that does. A header is otherwise a value anyone can send, and this one decides whether a route
+* that refuses clients answers instead; carrying a value from here closes that, because the value
+* rides only on requests this package makes and is never part of a response.
+*
+* Minted on first use rather than at module scope, where a runtime may refuse to generate it.
+*/
+let token;
+function backgroundToken() {
+	return token ??= crypto.randomUUID();
+}
+/**
+* Whether this request is the background render issued for the page beneath a modal.
+*
+* A route that answers a client with a redirect still has to render when it is the `base` of a
+* modal that client may open — otherwise the redirect is followed back to the modal and the chain
+* reports a cycle.
+*
+* A dispatcher that leaves the isolate answers `false` on the far side, which is the safe
+* direction: the route gates as it would for a client rather than opening for one.
+*
+* @example
+* ```typescript
+* if (isModalBackground(ctx)) return next()
+* ```
+*/
+function isModalBackground(ctx) {
+	return ctx.c.req.header(MODAL_DOCUMENT_HEADER) === backgroundToken();
+}
+let HonoBackgroundDispatcher = class HonoBackgroundDispatcher {
 	app;
-	ssr;
-	template;
-	constructor(app, ssr, template) {
+	constructor(app) {
 		this.app = app;
-		this.ssr = ssr;
-		this.template = template;
 	}
-	async render(ctx, component, props, options) {
-		const isInertia = ctx.c.req.header("x-inertia") === "true";
-		const partialComponent = ctx.c.req.header("x-inertia-partial-component");
-		const partialData = ctx.c.req.header("x-inertia-partial-data");
-		const redirectURL = this.resolveRedirectURL(ctx, options.baseURL);
-		const key = ctx.c.req.header("x-inertia-modal-key") ?? crypto.randomUUID();
-		const modalURL = new URL(ctx.c.req.url).pathname;
-		if (isInertia && partialComponent && partialData) {
-			if (partialData.split(",").map((s) => s.trim()).includes("modal")) {
-				const page = {
-					component: partialComponent,
-					props: {
-						modal: {
-							component,
-							props,
-							baseURL: options.baseURL,
-							redirectURL,
-							key,
-							nativeBack: true
-						},
-						errors: {}
-					},
-					url: modalURL,
-					version: null,
-					flash: {},
-					rememberedState: {},
-					rescuedProps: []
-				};
-				return new Response(JSON.stringify(page), {
-					status: 200,
-					headers: {
-						"Content-Type": "application/json",
-						"X-Inertia": "true",
-						"Vary": "X-Inertia"
-					}
-				});
+	fetch(request, ctx) {
+		const marked = markNestedDispatch(new Request(request));
+		marked.headers.set(MODAL_DOCUMENT_HEADER, backgroundToken());
+		return this.app.fetch(marked, ctx.c.env, ctx.c.executionCtx);
+	}
+};
+HonoBackgroundDispatcher = __decorate([Transient(), __decorateParam(0, inject(ROUTER_TOKENS.HonoApp))], HonoBackgroundDispatcher);
+/**
+* Headers a background render needs to answer as the caller would have been answered.
+*
+* The host and the forwarded set matter because middleware reconstructs the canonical request URL
+* from them, and auth derives its cookie name from that URL's protocol — without them a background
+* render is unauthenticated even though the cookie was forwarded.
+*/
+const FORWARDED_HEADERS = [
+	"cookie",
+	"host",
+	"x-forwarded-proto",
+	"x-forwarded-host",
+	"x-forwarded-for",
+	"x-forwarded-port",
+	"x-real-ip",
+	"accept-language",
+	"user-agent"
+];
+let ModalBackground = class ModalBackground {
+	dispatcher;
+	constructor(dispatcher) {
+		this.dispatcher = dispatcher;
+	}
+	async chainFor(ctx, base) {
+		const origin = new URL(ctx.c.req.url).origin;
+		const levels = [];
+		const followed = /* @__PURE__ */ new Set();
+		let next = base;
+		for (;;) {
+			const url = new URL(next, origin);
+			if (followed.has(url.pathname)) throw new ModalBaseCycleError(url.pathname);
+			followed.add(url.pathname);
+			const response = await this.dispatcher.fetch(this.requestFor(ctx, url), ctx);
+			const body = await response.text();
+			if (body === "" || response.status >= 300) throw new ModalBackgroundFetchError();
+			let page;
+			try {
+				page = JSON.parse(body);
+			} catch (error) {
+				throw new ModalBackgroundFetchError(error);
 			}
+			if (response.headers.get("stratal-modal") !== "true") return {
+				page,
+				levels
+			};
+			const level = page.props[MODAL_PROP];
+			if (!isModalData(level)) throw new ModalBackgroundFetchError();
+			levels.unshift(level);
+			next = level.base;
 		}
-		const modalData = {
+	}
+	requestFor(ctx, url) {
+		const headers = new Headers({
+			"x-inertia": "true",
+			"accept": "application/json"
+		});
+		for (const name of FORWARDED_HEADERS) {
+			const value = ctx.c.req.header(name);
+			if (value !== void 0 && value !== "") headers.set(name, value);
+		}
+		return new Request(url.toString(), {
+			method: "GET",
+			headers
+		});
+	}
+};
+ModalBackground = __decorate([Transient(), __decorateParam(0, inject(MODAL_TOKENS.BackgroundDispatcher))], ModalBackground);
+//#endregion
+//#region src/core/close-target.ts
+/**
+* Where a level lands when it closes.
+*
+* Resolved ONCE, when the level opens, and echoed by the client on every later request for it. A
+* target re-derived per answer drifts: on a refresh the browser's `Referer` is the sheet itself, so
+* the referer branch stops matching and the answer silently falls back to `base` — losing whatever
+* query the list had.
+*/
+/**
+* The page this level closes onto.
+*
+* The referer is preferred because it is the page the user is actually looking at, query and all,
+* where `base` is usually written query-free.
+*/
+function resolveCloseTarget({ referer, base, requestURL, origin, held }) {
+	if (referer === null) return base;
+	let refererURL;
+	try {
+		refererURL = new URL(referer);
+	} catch {
+		return base;
+	}
+	if (refererURL.origin !== origin) return base;
+	const refererPath = levelPath(refererURL.pathname);
+	if (!samePath(refererPath, base) && held.some((url) => samePath(url, refererPath))) return base;
+	if (samePath(refererURL.pathname, new URL(requestURL).pathname)) return base;
+	return `${refererURL.pathname}${refererURL.search}`;
+}
+//#endregion
+//#region src/core/level-props.ts
+const PREFIX = `${MODAL_PROP}.props.`;
+const ARRAY_KEYS = [
+	"mergeProps",
+	"prependProps",
+	"deepMergeProps",
+	"matchPropsOn"
+];
+const RECORD_OF_ARRAY_KEYS = ["deferredProps"];
+/** Rewrites every metadata entry on `page` to address `modal.props.*`. */
+function anchorPropMetadata(page) {
+	const anchored = { ...page };
+	for (const key of ARRAY_KEYS) {
+		const value = anchored[key];
+		if (Array.isArray(value)) anchored[key] = value.map((entry) => `${PREFIX}${String(entry)}`);
+	}
+	for (const key of RECORD_OF_ARRAY_KEYS) {
+		const value = anchored[key];
+		if (isRecord(value)) anchored[key] = Object.fromEntries(Object.entries(value).map(([group, names]) => [group, names.map((name) => `${PREFIX}${name}`)]));
+	}
+	const scrollProps = anchored.scrollProps;
+	if (isRecord(scrollProps)) anchored.scrollProps = Object.fromEntries(Object.entries(scrollProps).map(([name, entry]) => [`${PREFIX}${name}`, entry]));
+	const onceProps = anchored.onceProps;
+	if (isRecord(onceProps)) anchored.onceProps = Object.fromEntries(Object.entries(onceProps).map(([name, entry]) => [`${PREFIX}${name}`, {
+		...entry,
+		prop: `${PREFIX}${entry.prop}`
+	}]));
+	return anchored;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function levelAskFor(partialData) {
+	if (partialData === null || partialData.trim() === "") return { kind: "whole" };
+	const modalNames = partialData.split(",").map((name) => name.trim()).filter((name) => isModalPropPath(name));
+	if (modalNames.length === 0) return { kind: "unchanged" };
+	if (modalNames.includes("modal")) return { kind: "whole" };
+	return {
+		kind: "props",
+		names: levelPropNames(modalNames)
+	};
+}
+/**
+* The level-relative names among a page-anchored list, dropping any addressed elsewhere.
+*
+* Inertia's prop metadata travels page-anchored, because `modal.props.x` is where the client sees
+* the prop. The level's own props are keyed by the bare name, so anything resolving them has to ask
+* in those terms or it names nothing that exists.
+*/
+function levelPropNames(names) {
+	return names.filter((name) => name.startsWith(PREFIX)).map((name) => name.slice(PREFIX.length));
+}
+//#endregion
+//#region src/server/modal.service.ts
+let ModalService = class ModalService {
+	documentRenderer;
+	inertia;
+	seo;
+	background;
+	constructor(documentRenderer, inertia, seo, background) {
+		this.documentRenderer = documentRenderer;
+		this.inertia = inertia;
+		this.seo = seo;
+		this.background = background;
+	}
+	async render(ctx, component, props, options) {
+		const isInertia = ctx.header("x-inertia") === "true";
+		const requestURL = new URL(ctx.c.req.url);
+		const referer = ctx.header("referer") ?? null;
+		const close = resolveCloseTarget({
+			referer,
+			base: options.base,
+			requestURL: ctx.c.req.url,
+			origin: requestURL.origin,
+			held: decodeHeldLevels(ctx.header("stratal-modal-held") ?? null)
+		});
+		const ask = this.askedOf(ctx, referer, requestURL);
+		const resolution = ask.kind === "unchanged" ? EMPTY_RESOLUTION : await this.inertia.resolveProps(props, this.levelRequest(this.inertia.partialRequestFor(ctx, component, isInertia), ask));
+		const modal = {
 			component,
-			props,
-			baseURL: options.baseURL,
-			redirectURL,
-			key,
-			nativeBack: false
+			props: resolution.resolvedProps,
+			url: `${requestURL.pathname}${requestURL.search}`,
+			base: options.base,
+			close
 		};
-		const bgResponse = await this.fetchBackground(ctx, redirectURL);
-		const bgText = await bgResponse.text();
-		if (!bgText || bgResponse.status >= 300) throw new ModalBackgroundFetchError();
-		const bgPage = JSON.parse(bgText);
-		const combinedPage = {
-			...bgPage,
+		const anchored = anchorPropMetadata(metadataOf(resolution));
+		const seoProp = this.seo.contributed() ? { seo: await this.seo.resolve(ctx) } : {};
+		const { flash, errors } = this.flashFrom(ctx);
+		if (isInertia) return this.json({
+			component,
+			props: {
+				...ask.kind === "unchanged" ? {} : { [MODAL_PROP]: modal },
+				errors,
+				...seoProp
+			},
+			url: modal.url,
+			version: null,
+			flash,
+			rememberedState: {},
+			rescuedProps: [],
+			...anchored
+		});
+		const chain = await this.background.chainFor(ctx, options.base);
+		const page = {
+			...chain.page,
 			props: {
-				...bgPage.props,
-				modal: modalData
+				...chain.page.props,
+				errors,
+				[MODAL_PROP]: modal,
+				[MODAL_BENEATH_PROP]: chain.levels
 			},
-			url: modalURL
+			url: modal.url,
+			flash,
+			...mergeMetadata(chain.page, anchored)
+		};
+		const seoTags = this.seo.contributed() ? this.applyLevelSeo(page, await this.seo.resolve(ctx)) : [];
+		return this.documentRenderer.render(page, 200, seoTags);
+	}
+	/**
+	* The partial request as the level's own props see it.
+	*
+	* Inertia decides what to resolve by matching the request's names against the keys of the record
+	* it is given, and the two are in different namespaces here: the names arrive page-anchored
+	* (`modal.props.items`), while the record is the level's own props keyed bare (`items`). Passed
+	* through untranslated, a partial reload names nothing that exists — every prop is skipped, a
+	* deferred one is never resolved, and the level answers empty. `<Deferred>` reads that as the
+	* prop still being missing and asks again, which is a loop that does not end.
+	*
+	* `isPartial` is taken from what the request names rather than from `request.isPartial`, which
+	* is false for every level. Inertia decides that by comparing `X-Inertia-Partial-Component`
+	* against the component being rendered, and the client sends the component of the page it holds
+	* — the page beneath, since a level is grafted onto it as a prop, not swapped in for it. So the
+	* comparison is between a page and a level and can never match. `narrowedTo` has already
+	* established that this request is addressed to this level, by the referer, which is the signal
+	* that actually means what `isPartial` is being asked here.
+	*
+	* `null` resolves the level whole, covering both of its readings: a request addressed elsewhere,
+	* and one asking for the level itself.
+	*/
+	levelRequest(request, ask) {
+		return {
+			...request,
+			isPartial: ask.kind === "props",
+			requested: ask.kind === "props" ? ask.names : [],
+			except: levelPropNames(request.except),
+			reset: levelPropNames(request.reset)
 		};
-		if (isInertia) return new Response(JSON.stringify(combinedPage), {
+	}
+	/**
+	* What this request asks of the level.
+	*
+	* Answering with anything but the whole level is only safe when the client is already looking at
+	* it, because a narrowed answer is merged over the props it holds and an `unchanged` one carries
+	* none at all. `Referer` is what says so: an XHR from inside the sheet reports the sheet's own
+	* url, while a partial re-issued into a modal route by a redirect reports the page the request
+	* started from. Its partial headers survive that redirect unchanged, so without this check such
+	* a response would leave the level with holes nothing will ever fill.
+	*/
+	askedOf(ctx, referer, requestURL) {
+		if (referer === null) return { kind: "whole" };
+		let refererURL;
+		try {
+			refererURL = new URL(referer);
+		} catch {
+			return { kind: "whole" };
+		}
+		if (refererURL.origin !== requestURL.origin || refererURL.pathname !== requestURL.pathname) return { kind: "whole" };
+		return levelAskFor(ctx.header("x-inertia-partial-data") ?? null);
+	}
+	/** Writes a level's resolved SEO onto the page and returns its head tags. */
+	applyLevelSeo(page, resolved) {
+		page.props.seo = resolved;
+		return this.seo.tagsFor(resolved);
+	}
+	/**
+	* The validation errors this response carries.
+	*
+	* Load-bearing on this path rather than incidental: a failed submission redirects back into the
+	* modal route, and `preserveState: 'errors'` resolves against the response — an empty record here
+	* closes the sheet the user was filling in.
+	*/
+	flashFrom(ctx) {
+		const { errors: rawErrors, ...flash } = ctx.c.get("inertiaFlash") ?? {};
+		return {
+			flash,
+			errors: rawErrors !== void 0 && typeof rawErrors === "object" && !Array.isArray(rawErrors) && rawErrors !== null ? rawErrors : {}
+		};
+	}
+	json(page) {
+		return new Response(JSON.stringify(page), {
 			status: 200,
 			headers: {
 				"Content-Type": "application/json",
 				"X-Inertia": "true",
+				[MODAL_MARKER_HEADER]: "true",
 				"Vary": "X-Inertia"
 			}
 		});
-		const { head, stream } = await this.ssr.render(combinedPage);
-		const body = this.template.renderStream(combinedPage, head, stream);
-		return new Response(body, {
-			status: 200,
-			headers: { "Content-Type": "text/html; charset=utf-8" }
-		});
-	}
-	resolveRedirectURL(ctx, baseURL) {
-		const referer = ctx.c.req.header("referer");
-		if (ctx.c.req.header("x-inertia") === "true" && referer) try {
-			const refererURL = new URL(referer);
-			const currentURL = new URL(ctx.c.req.url);
-			if (refererURL.pathname !== currentURL.pathname) return refererURL.pathname + refererURL.search;
-		} catch {}
-		return baseURL;
-	}
-	async fetchBackground(ctx, url) {
-		const currentURL = new URL(ctx.c.req.url);
-		const bgURL = new URL(url, currentURL.origin);
-		const headers = {
-			"x-inertia": "true",
-			"x-inertia-resolve-deferred": "true",
-			"accept": "application/json",
-			"cookie": ctx.c.req.header("cookie") ?? "",
-			"host": ctx.c.req.header("host") ?? ""
-		};
-		for (const name of [
-			"x-forwarded-proto",
-			"x-forwarded-host",
-			"x-forwarded-for",
-			"x-forwarded-port",
-			"x-real-ip",
-			"accept-language",
-			"user-agent"
-		]) {
-			const value = ctx.c.req.header(name);
-			if (value) headers[name] = value;
-		}
-		const bgRequest = new Request(bgURL.toString(), {
-			method: "GET",
-			headers
-		});
-		return this.app.fetch(bgRequest, ctx.c.env, ctx.c.executionCtx);
 	}
 };
 ModalService = __decorate([
 	Request$1(),
-	__decorateParam(0, inject(ROUTER_TOKENS.HonoApp)),
-	__decorateParam(1, inject(INERTIA_TOKENS.SsrRenderer)),
-	__decorateParam(2, inject(INERTIA_TOKENS.TemplateService))
+	__decorateParam(0, inject(INERTIA_TOKENS.DocumentRenderer)),
+	__decorateParam(1, inject(INERTIA_TOKENS.InertiaService)),
+	__decorateParam(2, inject(INERTIA_TOKENS.SeoService)),
+	__decorateParam(3, inject(ModalBackground))
 ], ModalService);
+/** What a level contributes when the request asked nothing of it. */
+const EMPTY_RESOLUTION = {
+	resolvedProps: {},
+	mergeProps: [],
+	prependProps: [],
+	deepMergeProps: [],
+	matchPropsOn: [],
+	scrollProps: {},
+	deferredProps: {},
+	onceProps: {}
+};
+/** A resolution's metadata in the shape a page object carries it. */
+function metadataOf(resolution) {
+	return {
+		...resolution.mergeProps.length > 0 ? { mergeProps: resolution.mergeProps } : {},
+		...resolution.prependProps.length > 0 ? { prependProps: resolution.prependProps } : {},
+		...resolution.deepMergeProps.length > 0 ? { deepMergeProps: resolution.deepMergeProps } : {},
+		...resolution.matchPropsOn.length > 0 ? { matchPropsOn: resolution.matchPropsOn } : {},
+		...Object.keys(resolution.scrollProps).length > 0 ? { scrollProps: resolution.scrollProps } : {},
+		...Object.keys(resolution.deferredProps).length > 0 ? { deferredProps: resolution.deferredProps } : {},
+		...Object.keys(resolution.onceProps).length > 0 ? { onceProps: resolution.onceProps } : {}
+	};
+}
+/** The page's own metadata with the level's anchored metadata added to it. */
+function mergeMetadata(base, anchored) {
+	const deferredProps = { ...base.deferredProps };
+	for (const [group, names] of Object.entries(anchored.deferredProps ?? {})) deferredProps[group] = [...deferredProps[group] ?? [], ...names];
+	const mergeProps = [...base.mergeProps ?? [], ...anchored.mergeProps ?? []];
+	const prependProps = [...base.prependProps ?? [], ...anchored.prependProps ?? []];
+	const deepMergeProps = [...base.deepMergeProps ?? [], ...anchored.deepMergeProps ?? []];
+	const matchPropsOn = [...base.matchPropsOn ?? [], ...anchored.matchPropsOn ?? []];
+	const scrollProps = {
+		...base.scrollProps,
+		...anchored.scrollProps
+	};
+	const onceProps = {
+		...base.onceProps,
+		...anchored.onceProps
+	};
+	return {
+		...mergeProps.length > 0 ? { mergeProps } : {},
+		...prependProps.length > 0 ? { prependProps } : {},
+		...deepMergeProps.length > 0 ? { deepMergeProps } : {},
+		...matchPropsOn.length > 0 ? { matchPropsOn } : {},
+		...Object.keys(scrollProps).length > 0 ? { scrollProps } : {},
+		...Object.keys(deferredProps).length > 0 ? { deferredProps } : {},
+		...Object.keys(onceProps).length > 0 ? { onceProps } : {}
+	};
+}
 //#endregion
 //#region src/modal.module.ts
 let ModalModule = class ModalModule {
@@ -178,11 +486,17 @@ let ModalModule = class ModalModule {
 		});
 	}
 };
-ModalModule = __decorate([Module({ providers: [{
-	provide: MODAL_TOKENS.ModalService,
-	useClass: ModalService
-}] })], ModalModule);
+ModalModule = __decorate([Module({
+	imports: [I18nModule.registerMessages({ en: { modal: modalMessages.en } })],
+	providers: [{
+		provide: MODAL_TOKENS.ModalService,
+		useClass: ModalService
+	}, {
+		provide: MODAL_TOKENS.BackgroundDispatcher,
+		useClass: HonoBackgroundDispatcher
+	}]
+})], ModalModule);
 //#endregion
-export { MODAL_TOKENS, ModalModule };
+export { MODAL_BENEATH_PROP, MODAL_DOCUMENT_HEADER, MODAL_MARKER_HEADER, MODAL_PROP, MODAL_TOKENS, ModalBackgroundFetchError, ModalBaseCycleError, ModalModule, isModalBackground, modalMessages };
 
 //# sourceMappingURL=index.mjs.map