@ecopages/core 0.2.0-alpha.26 → 0.2.0-alpha.27

package/src/eco/eco.ts

@@ -0,0 +1,205 @@
+/**
+ * The eco namespace - unified component and page factory API
+ * @module
+ */
+
+import type {
+	EcoComponent,
+	EcoHtmlComponent,
+	EcoLayoutComponent,
+	EcoPagesElement,
+	EcoPageComponent,
+	FileRouteMiddleware,
+	GetMetadata,
+	GetStaticPaths,
+	GetStaticProps,
+	RequestLocals,
+	RequestPageContext,
+} from '../types/public-types.ts';
+import type { CacheStrategy } from '../services/cache/cache.types.ts';
+import type {
+	ComponentOptions,
+	Eco,
+	HtmlOptions,
+	LayoutOptions,
+	PageOptions,
+	PageOptionsBase,
+	PagePropsFor,
+	PagePropsForWithLocals,
+	PageRequires,
+} from './eco.types.ts';
+import {
+	finalizeComponentRender,
+	interceptForeignChild,
+} from '../route-renderer/orchestration/component-render-context.ts';
+import { isThenable } from '../route-renderer/orchestration/render-output.utils.ts';
+
+/**
+ * Creates a component factory with lazy-trigger support and foreign-child-runtime
+ * interception.
+ *
+ * Behavior:
+ * - In normal render flow, returns `options.render(props)` with optional lazy
+ *   trigger/script wrapping.
+ * - When rendering under an active foreign-child runtime and the current
+ *   renderer-owned foreign-child runtime resolves the foreign child immediately, returns
+ *   that resolved output instead of rendering the component inline.
+ *
+ * @param options Component options for rendering and dependency declaration.
+ * @returns Configured eco component.
+ */
+function createComponentFactory<P, E>(options: ComponentOptions<P, E>): EcoComponent<P, E> {
+	const integrationName = options.integration ?? options.__eco?.integration;
+	const comp: EcoComponent<P, E> = ((props: P) => {
+		const componentProps = (props ?? {}) as Record<string, unknown>;
+		const renderInline = () => finalizeComponentRender(comp, options.render(props)) as E;
+		const foreignChildRender = interceptForeignChild({
+			component: comp,
+			props: componentProps,
+			targetIntegration: integrationName,
+		});
+
+		if (isThenable<unknown | undefined>(foreignChildRender)) {
+			return foreignChildRender.then((resolvedForeignChildRender) =>
+				resolvedForeignChildRender !== undefined ? (resolvedForeignChildRender as E) : renderInline(),
+			) as E;
+		}
+
+		if (foreignChildRender !== undefined) {
+			return foreignChildRender as E;
+		}
+
+		return renderInline();
+	}) as EcoComponent<P, E>;
+
+	comp.config = {
+		__eco: options.__eco,
+		integration: options.integration,
+		dependencies: options.dependencies,
+	};
+
+	return comp;
+}
+
+/**
+ * Creates a reusable component with optional dependencies.
+ *
+ * @param options Component definition options.
+ * @returns Eco component function.
+ */
+function component<P = {}, E = EcoPagesElement>(options: ComponentOptions<P, E>): EcoComponent<P, E> {
+	return createComponentFactory(options);
+}
+
+/**
+ * Creates a document shell component.
+ *
+ * Phase 1 keeps this as a semantic alias over eco.component() so existing
+ * renderer behavior remains unchanged.
+ */
+function html<E = EcoPagesElement>(options: HtmlOptions<E>): EcoHtmlComponent<E> {
+	return createComponentFactory(options) as EcoHtmlComponent<E>;
+}
+
+/**
+ * Creates a route layout component.
+ *
+ * Phase 1 keeps this as a semantic alias over eco.component() so existing
+ * renderer behavior remains unchanged.
+ */
+function layout<E = EcoPagesElement>(options: LayoutOptions<E>): EcoLayoutComponent<E> {
+	return createComponentFactory(options) as EcoLayoutComponent<E>;
+}
+
+/**
+ * Creates a page component with typed props and optional static helpers.
+ */
+function page<T = {}, E = EcoPagesElement>(options: PageOptions<T, E> & { requires?: undefined }): EcoPageComponent<T>;
+function page<T = {}, E = EcoPagesElement, const K extends keyof RequestLocals = keyof RequestLocals>(
+	options: Omit<PageOptions<T, E>, 'render' | 'requires'> & {
+		requires: PageRequires<K>;
+		render: (props: PagePropsForWithLocals<T, K>) => E | Promise<E>;
+	},
+): EcoPageComponent<T>;
+
+/**
+ * Creates a page component and attaches optional static APIs.
+ *
+ * @param options Page options.
+ * @returns Eco page component.
+ */
+function page<T, E>(
+	options: PageOptionsBase<T, E> & { cache?: CacheStrategy; middleware?: FileRouteMiddleware[] },
+): EcoPageComponent<T> {
+	const { layout, dependencies, render, staticPaths, staticProps, metadata, cache, requires, middleware } = options;
+
+	const componentOptions: ComponentOptions<PagePropsFor<T> & Partial<RequestPageContext>, E> = {
+		__eco: options.__eco,
+		integration: options.integration,
+		dependencies: layout
+			? {
+					...dependencies,
+					components: [...(dependencies?.components || []), layout],
+				}
+			: dependencies,
+		render,
+	};
+
+	const pageComponent = createComponentFactory(componentOptions) as EcoPageComponent<T>;
+
+	if (layout && pageComponent.config) {
+		pageComponent.config.layout = layout;
+	}
+
+	if (staticPaths) pageComponent.staticPaths = staticPaths;
+	if (staticProps) pageComponent.staticProps = staticProps;
+	if (metadata) pageComponent.metadata = metadata;
+	if (cache) pageComponent.cache = cache;
+	if (requires) pageComponent.requires = requires;
+	if (middleware) pageComponent.middleware = middleware;
+
+	return pageComponent;
+}
+
+/**
+ * Type-safe wrapper for metadata functions.
+ *
+ * @param fn Metadata factory function.
+ * @returns The same function.
+ */
+function metadata<P = {}>(fn: GetMetadata<P>): GetMetadata<P> {
+	return fn;
+}
+
+/**
+ * Type-safe wrapper for static paths functions.
+ *
+ * @param fn Static paths function.
+ * @returns The same function.
+ */
+function staticPaths(fn: GetStaticPaths): GetStaticPaths {
+	return fn;
+}
+
+/**
+ * Type-safe wrapper for static props functions.
+ *
+ * @param fn Static props function.
+ * @returns The same function.
+ */
+function staticProps<P>(fn: GetStaticProps<P>): GetStaticProps<P> {
+	return fn;
+}
+
+/**
+ * The eco namespace - provides factories for components and pages
+ */
+export const eco: Eco = {
+	component,
+	html,
+	layout,
+	page,
+	metadata,
+	staticPaths,
+	staticProps,
+};

package/src/eco/eco.types.ts

@@ -0,0 +1,221 @@
+/**
+ * Type definitions for the eco namespace API
+ * @module
+ */
+
+import type {
+	DependencyLazyTrigger,
+	EcoComponent,
+	EcoComponentDependencies,
+	EcoHtmlComponent,
+	EcoInjectedMeta,
+	EcoLayoutComponent,
+	EcoPageLayoutComponent,
+	EcoPagesElement,
+	FileRouteMiddleware,
+	GetMetadata,
+	GetStaticPaths,
+	GetStaticProps,
+	HtmlTemplateProps,
+	LayoutProps,
+	RequestLocals,
+	RequestPageContext,
+} from '../types/public-types.ts';
+import type { CacheStrategy } from '../services/cache/cache.types.ts';
+
+type WithRequiredLocals<K extends keyof RequestLocals> = Omit<RequestLocals, K> & {
+	[P in K]-?: Exclude<RequestLocals[P], null | undefined>;
+};
+
+type RequiresKeys = keyof RequestLocals;
+
+export type PageRequires<K extends RequiresKeys = RequiresKeys> = K | readonly K[];
+
+/**
+ * Lazy trigger options map directly to scripts-injector attributes.
+ * Only one trigger type can be active at a time.
+ */
+export type LazyTrigger = DependencyLazyTrigger;
+
+/**
+ * Options for creating a component with eco.component()
+ * @template P - The props type for the component
+ * @template E - The element/return type (defaults to EcoPagesElement for Kita, use ReactNode for React)
+ */
+export interface ComponentOptions<P, E = EcoPagesElement> {
+	/** @internal Injected by eco-component-meta-plugin */
+	__eco?: EcoInjectedMeta;
+	integration?: string;
+	dependencies?: EcoComponentDependencies;
+	render: (props: P) => E | Promise<E>;
+}
+
+export type HtmlOptions<E = EcoPagesElement> = ComponentOptions<HtmlTemplateProps, E>;
+
+export type LayoutOptions<E = EcoPagesElement> = ComponentOptions<LayoutProps<E>, E>;
+
+/**
+ * Base options shared by all page variants
+ */
+export interface PageOptionsBase<T, E = EcoPagesElement> {
+	/** @internal Injected by eco-component-meta-plugin */
+	__eco?: EcoInjectedMeta;
+	integration?: string;
+	dependencies?: EcoComponentDependencies;
+	layout?: EcoPageLayoutComponent<E>;
+
+	/**
+	 * Define static paths for dynamic routes (e.g., [slug].tsx).
+	 * Returns all possible paths that should be pre-rendered at build time.
+	 */
+	staticPaths?: GetStaticPaths;
+
+	/**
+	 * Fetch data for the page at build time.
+	 * Props returned here are passed to both render() and metadata().
+	 */
+	staticProps?: GetStaticProps<T>;
+
+	/**
+	 * Generate page metadata (title, description, etc.).
+	 * Receives props from staticProps if defined.
+	 */
+	metadata?: GetMetadata<T>;
+
+	/**
+	 * Declares which `locals` keys must be present for this page.
+	 *
+	 * This is a typing and documentation feature; runtime enforcement must be done via handler/page middleware.
+	 */
+	requires?: PageRequires;
+
+	render: (props: PagePropsFor<T> & Partial<RequestPageContext>) => E | Promise<E>;
+}
+
+/**
+ * Page options without middleware - allows any cache strategy
+ */
+interface PageOptionsWithoutMiddleware<T, E = EcoPagesElement> extends PageOptionsBase<T, E> {
+	/**
+	 * Cache configuration for ISR (Incremental Static Regeneration).
+	 * - `'static'`: Cache indefinitely (default)
+	 * - `'dynamic'`: No caching, render on every request
+	 * - `{ revalidate: number, tags?: string[] }`: Cache with time-based revalidation
+	 */
+	cache?: CacheStrategy;
+	middleware?: undefined;
+}
+
+/**
+ * Page options with middleware - requires cache: 'dynamic'
+ */
+interface PageOptionsWithMiddleware<T, E = EcoPagesElement> extends PageOptionsBase<T, E> {
+	/**
+	 * Cache must be 'dynamic' when using middleware.
+	 * Middleware runs on every request, so caching would bypass middleware effects.
+	 */
+	cache: 'dynamic';
+	/**
+	 * Request-time middleware for file-based routes.
+	 * Runs before rendering and can short-circuit by returning a Response.
+	 */
+	middleware: FileRouteMiddleware[];
+}
+
+/**
+ * Options for creating a page with eco.page()
+ *
+ * Supports two patterns:
+ * 1. **Consolidated API** (recommended): Define staticPaths, staticProps, and metadata inline
+ * 2. **Separate exports** (legacy): Export getStaticPaths, getStaticProps, getMetadata separately
+ *
+ * When using `middleware`, `cache` must be set to `'dynamic'` because middleware
+ * runs on every request and caching would bypass middleware effects.
+ *
+ * @template T - The props type for the page
+ * @template E - The element/return type (defaults to EcoPagesElement for Kita, use ReactNode for React)
+ */
+export type PageOptions<T, E = EcoPagesElement> = PageOptionsWithoutMiddleware<T, E> | PageOptionsWithMiddleware<T, E>;
+
+export type PagePropsForWithLocals<T, K extends RequiresKeys | never = never> = PagePropsFor<T> &
+	(K extends never
+		? Partial<RequestPageContext>
+		: Omit<Partial<RequestPageContext>, 'locals'> & {
+				locals: WithRequiredLocals<Extract<K, keyof RequestLocals>>;
+			});
+
+/**
+ * Extracts props type from getStaticProps return type, or uses T directly if it's a props object.
+ * Always includes params and query for page context.
+ */
+export type PagePropsFor<T> =
+	T extends GetStaticProps<infer P>
+		? P & { params?: Record<string, string>; query?: Record<string, string> }
+		: T & { params?: Record<string, string>; query?: Record<string, string> };
+
+/**
+ * A page component with optional attached static functions.
+ * Used by the consolidated eco.page() API where staticPaths, staticProps,
+ * and metadata are defined inline and attached to the component.
+ */
+export type EcoPageComponent<T> = EcoComponent<PagePropsFor<T> & Partial<RequestPageContext>> & {
+	staticPaths?: GetStaticPaths;
+	staticProps?: GetStaticProps<T>;
+	metadata?: GetMetadata<T>;
+	cache?: CacheStrategy;
+	requires?: PageRequires;
+	middleware?: FileRouteMiddleware[];
+};
+
+/**
+ * The eco namespace interface
+ */
+export interface Eco {
+	/**
+	 * Create a reusable component with dependencies and optional lazy-loading.
+	 * @template P - Props type
+	 * @template E - Element/return type (EcoPagesElement for Kita, ReactNode for React)
+	 */
+	component: <P = {}, E = EcoPagesElement>(options: ComponentOptions<P, E>) => EcoComponent<P, E>;
+
+	/**
+	 * Create a document shell component for the HTML wrapper.
+	 */
+	html: <E = EcoPagesElement>(options: HtmlOptions<E>) => EcoHtmlComponent<E>;
+
+	/**
+	 * Create a route layout component.
+	 */
+	layout: <E = EcoPagesElement>(options: LayoutOptions<E>) => EcoLayoutComponent<E>;
+
+	/**
+	 * Create a page component with type-safe props from getStaticProps.
+	 * Returns an EcoPageComponent with attached staticPaths, staticProps, and metadata.
+	 *
+	 * If `requires` is provided, the `render` callback receives `locals` as required and non-null for the required keys.
+	 */
+	page: {
+		<T = {}, E = EcoPagesElement>(options: PageOptions<T, E> & { requires?: undefined }): EcoPageComponent<T>;
+		<T = {}, E = EcoPagesElement, const K extends RequiresKeys = RequiresKeys>(
+			options: Omit<PageOptions<T, E>, 'render' | 'requires'> & {
+				requires: PageRequires<K>;
+				render: (props: PagePropsForWithLocals<T, K>) => E | Promise<E>;
+			},
+		): EcoPageComponent<T>;
+	};
+
+	/**
+	 * Type-safe wrapper for page metadata (identity function)
+	 */
+	metadata: <P = {}>(fn: GetMetadata<P>) => GetMetadata<P>;
+
+	/**
+	 * Type-safe wrapper for static paths (identity function)
+	 */
+	staticPaths: (fn: GetStaticPaths) => GetStaticPaths;
+
+	/**
+	 * Type-safe wrapper for static props (identity function)
+	 */
+	staticProps: <P>(fn: GetStaticProps<P>) => GetStaticProps<P>;
+}

package/src/eco/eco.utils.test.ts

@@ -0,0 +1,219 @@
+import { describe, expect, test } from 'vitest';
+import { addTriggerAttribute, isThenable, wrapWithScriptsInjector } from './eco.utils.ts';
+
+const TRIGGER_ID = 'eco-trigger-abc123';
+
+describe('addTriggerAttribute', () => {
+	describe('basic element injection', () => {
+		test('injects into a plain div', () => {
+			const result = addTriggerAttribute('<div>content</div>', TRIGGER_ID);
+			expect(result).toBe(`<div data-eco-trigger="${TRIGGER_ID}">content</div>`);
+		});
+
+		test('injects into a custom element', () => {
+			const result = addTriggerAttribute('<my-counter value="0"></my-counter>', TRIGGER_ID);
+			expect(result).toBe(`<my-counter data-eco-trigger="${TRIGGER_ID}" value="0"></my-counter>`);
+		});
+
+		test('injects into an element that already has attributes', () => {
+			const result = addTriggerAttribute('<div class="foo" id="bar">content</div>', TRIGGER_ID);
+			expect(result).toBe(`<div data-eco-trigger="${TRIGGER_ID}" class="foo" id="bar">content</div>`);
+		});
+
+		test('injects into a self-closing void element', () => {
+			const result = addTriggerAttribute('<img src="x.png" alt="" />', TRIGGER_ID);
+			expect(result).toBe(`<img data-eco-trigger="${TRIGGER_ID}" src="x.png" alt="" />`);
+		});
+
+		test('injects into an element with no attributes and immediate close', () => {
+			const result = addTriggerAttribute('<section></section>', TRIGGER_ID);
+			expect(result).toBe(`<section data-eco-trigger="${TRIGGER_ID}"></section>`);
+		});
+	});
+
+	describe('leading non-element nodes are skipped', () => {
+		test('skips leading whitespace and injects into the first element', () => {
+			const result = addTriggerAttribute('   \n  <div>content</div>', TRIGGER_ID);
+			expect(result).toBe(`   \n  <div data-eco-trigger="${TRIGGER_ID}">content</div>`);
+		});
+
+		test('skips a leading HTML comment', () => {
+			const result = addTriggerAttribute('<!-- wrapper --><div>content</div>', TRIGGER_ID);
+			expect(result).toBe(`<!-- wrapper --><div data-eco-trigger="${TRIGGER_ID}">content</div>`);
+		});
+
+		test('skips multiple leading HTML comments', () => {
+			const result = addTriggerAttribute('<!-- a --><!-- b --><span>text</span>', TRIGGER_ID);
+			expect(result).toBe(`<!-- a --><!-- b --><span data-eco-trigger="${TRIGGER_ID}">text</span>`);
+		});
+
+		test('skips a leading doctype declaration', () => {
+			const result = addTriggerAttribute('<!DOCTYPE html><html lang="en"></html>', TRIGGER_ID);
+			expect(result).toBe(`<!DOCTYPE html><html data-eco-trigger="${TRIGGER_ID}" lang="en"></html>`);
+		});
+
+		test('skips a leading XML processing instruction', () => {
+			const result = addTriggerAttribute('<?xml version="1.0"?><root/>', TRIGGER_ID);
+			expect(result).toBe(`<?xml version="1.0"?><root data-eco-trigger="${TRIGGER_ID}"/>`);
+		});
+
+		test('skips comment then whitespace then element', () => {
+			const result = addTriggerAttribute('<!-- note -->\n<article>body</article>', TRIGGER_ID);
+			expect(result).toBe(`<!-- note -->\n<article data-eco-trigger="${TRIGGER_ID}">body</article>`);
+		});
+	});
+
+	describe('only the first element is modified', () => {
+		test('does not inject into sibling elements', () => {
+			const result = addTriggerAttribute('<div>first</div><div>second</div>', TRIGGER_ID);
+			expect(result).toBe(`<div data-eco-trigger="${TRIGGER_ID}">first</div><div>second</div>`);
+		});
+	});
+
+	describe('fallback when no element is found', () => {
+		test('preserves JSX template metadata while injecting into the first string', () => {
+			const strings = ['<theme-toggle class=', '></theme-toggle>'];
+			Object.defineProperty(strings, 'raw', {
+				value: ['<theme-toggle class=', '></theme-toggle>'],
+			});
+
+			const template = {
+				_$rType$: 1,
+				rootLocalName: 'theme-toggle',
+				strings,
+				values: ['radiant-switch'],
+			};
+
+			const result = addTriggerAttribute(template, TRIGGER_ID) as unknown as {
+				_$rType$: number;
+				rootLocalName: string;
+				strings: string[];
+				values: unknown[];
+			};
+
+			expect(result._$rType$).toBe(1);
+			expect(result.rootLocalName).toBe('theme-toggle');
+			expect(result.values).toEqual(['radiant-switch']);
+			expect(result.strings).toEqual([
+				`<theme-toggle data-eco-trigger="${TRIGGER_ID}" class=`,
+				'></theme-toggle>',
+			]);
+			expect(Object.getOwnPropertyDescriptor(result.strings, 'raw')?.value).toEqual([
+				`<theme-toggle data-eco-trigger="${TRIGGER_ID}" class=`,
+				'></theme-toggle>',
+			]);
+		});
+
+		test('preserves SSR markup node output while injecting into outerHTML', () => {
+			const markupNode = {
+				nodeType: 1,
+				get outerHTML() {
+					return '<theme-toggle class="radiant-switch"></theme-toggle>';
+				},
+			};
+
+			const result = addTriggerAttribute(markupNode, TRIGGER_ID) as typeof markupNode;
+
+			expect(result.nodeType).toBe(1);
+			expect(result.outerHTML).toBe(
+				`<theme-toggle data-eco-trigger="${TRIGGER_ID}" class="radiant-switch"></theme-toggle>`,
+			);
+		});
+
+		test('returns the original string unchanged when there is no opening tag', () => {
+			const input = 'just some text';
+			expect(addTriggerAttribute(input, TRIGGER_ID)).toBe(input);
+		});
+
+		test('returns the original string unchanged when input is empty', () => {
+			expect(addTriggerAttribute('', TRIGGER_ID)).toBe('');
+		});
+	});
+
+	describe('non-string input coercion', () => {
+		test('coerces a number to string before injecting', () => {
+			const result = addTriggerAttribute(42, TRIGGER_ID);
+			expect(result).toBe('42');
+		});
+
+		test('coerces null to the string "null"', () => {
+			expect(addTriggerAttribute(null, TRIGGER_ID)).toBe('null');
+		});
+	});
+});
+
+describe('isThenable', () => {
+	test('returns true for a native Promise', () => {
+		expect(isThenable(Promise.resolve())).toBe(true);
+	});
+
+	test('returns true for a plain object with a then function', () => {
+		expect(isThenable({ then: () => {} })).toBe(true);
+	});
+
+	test('returns false for a plain string', () => {
+		expect(isThenable('hello')).toBe(false);
+	});
+
+	test('returns false for a number', () => {
+		expect(isThenable(42)).toBe(false);
+	});
+
+	test('returns false for null', () => {
+		expect(isThenable(null)).toBe(false);
+	});
+
+	test('returns false for an object without then', () => {
+		expect(isThenable({ value: 1 })).toBe(false);
+	});
+
+	test('returns false when then is not a function', () => {
+		expect(isThenable({ then: 'not-a-function' })).toBe(false);
+	});
+});
+
+describe('wrapWithScriptsInjector', () => {
+	const lazyGroups = [{ lazy: { 'on:idle': true }, scripts: '/_assets/script.js' }] as const;
+
+	test('preserves JSX template metadata while wrapping content', () => {
+		const strings = ['<theme-toggle class=', '></theme-toggle>'];
+		Object.defineProperty(strings, 'raw', {
+			value: ['<theme-toggle class=', '></theme-toggle>'],
+		});
+
+		const template = {
+			_$rType$: 1,
+			rootLocalName: 'theme-toggle',
+			strings,
+			values: ['radiant-switch'],
+		};
+
+		const result = wrapWithScriptsInjector(template, lazyGroups) as unknown as typeof template;
+
+		expect(result._$rType$).toBe(1);
+		expect(result.rootLocalName).toBe('theme-toggle');
+		expect(result.values).toEqual(['radiant-switch']);
+		expect(result.strings[0]).toContain('<scripts-injector><script type="ecopages/injector-map">');
+		expect(result.strings[0]).toContain('<theme-toggle class=');
+		expect(result.strings[1]).toBe('></theme-toggle></scripts-injector>');
+		expect(Object.getOwnPropertyDescriptor(result.strings, 'raw')?.value[1]).toBe(
+			'></theme-toggle></scripts-injector>',
+		);
+	});
+
+	test('preserves markup-node-like output while wrapping content', () => {
+		const markupNode = {
+			nodeType: 1,
+			get outerHTML() {
+				return '<theme-toggle class="radiant-switch"></theme-toggle>';
+			},
+		};
+
+		const result = wrapWithScriptsInjector(markupNode, lazyGroups) as typeof markupNode;
+
+		expect(result.nodeType).toBe(1);
+		expect(result.outerHTML).toContain('<scripts-injector><script type="ecopages/injector-map">');
+		expect(result.outerHTML).toContain('<theme-toggle class="radiant-switch"></theme-toggle>');
+		expect(result.outerHTML).toContain('</scripts-injector>');
+	});
+});

package/src/eco/eco.utils.ts

@@ -0,0 +1,5 @@
+export {
+	addTriggerAttribute,
+	isThenable,
+	wrapWithScriptsInjector,
+} from '../route-renderer/orchestration/render-output.utils.ts';

package/src/eco/global-injector-map.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test } from 'vitest';
+import { buildGlobalInjectorBootstrapContent, buildGlobalInjectorMapScript } from './global-injector-map.ts';
+import type { ResolvedLazyTrigger } from '../types/public-types.ts';
+
+describe('buildGlobalInjectorMapScript', () => {
+	test('builds merged map by trigger id and escapes script closing tags', () => {
+		const triggers: ResolvedLazyTrigger[] = [
+			{
+				triggerId: 'eco-trigger-one',
+				rules: [
+					{ 'on:interaction': { value: 'click', scripts: ['/a.js', '/b</script>.js'] } },
+					{ 'on:idle': { scripts: ['/idle.js'] } },
+				],
+			},
+			{
+				triggerId: 'eco-trigger-one',
+				rules: [{ 'on:interaction': { value: 'click', scripts: ['/a.js', '/c.js'] } }],
+			},
+		];
+
+		const payload = buildGlobalInjectorMapScript(triggers);
+		expect(payload).toContain('<\\/script>');
+
+		const map = JSON.parse(payload) as Record<string, Record<string, { scripts: string[]; value?: string }>>;
+		expect(map['eco-trigger-one']?.['on:idle']?.scripts).toEqual(['/idle.js']);
+		expect(map['eco-trigger-one']?.['on:interaction']).toEqual({
+			value: 'click',
+			scripts: ['/a.js', '/b</script>.js', '/c.js'],
+		});
+	});
+});
+
+describe('buildGlobalInjectorBootstrapContent', () => {
+	test('binds refresh to after-swap and avoids before-swap cleanup listener', () => {
+		const bootstrap = buildGlobalInjectorBootstrapContent('/assets/injector-global.js');
+
+		expect(bootstrap).toContain("document.addEventListener('eco:after-swap', handleAfterSwap);");
+		expect(bootstrap).not.toContain("document.addEventListener('eco:before-swap'");
+		expect(bootstrap).not.toContain('const handleBeforeSwap');
+		expect(bootstrap).toContain("document.removeEventListener('eco:after-swap', handleAfterSwap);");
+	});
+});