@jfdevelops/react-layout 1.6.1 → 2.1.0

package/dist/lazy/create-lazy-loader.cjs

@@ -0,0 +1,78 @@
+const require_resource_state_error = require('../errors/resource-state-error.cjs');
+const require_lazy_resource_error = require('../errors/lazy-resource-error.cjs');
+let react = require("react");
+
+//#region src/lazy/create-lazy-loader.ts
+/** A single import cache and lifecycle shared by every lazy entry point. */
+function createLazyLoader(options) {
+	let promise;
+	let preloadPromise;
+	let status = "unresolved";
+	const components = /* @__PURE__ */ new Map();
+	let generation = 0;
+	function get() {
+		if (promise) return promise;
+		const attempt = generation;
+		status = "loading";
+		options.hooks?.onLoadStart?.();
+		promise = Promise.resolve().then(options.load).catch((cause) => {
+			if (require_lazy_resource_error.isLazyResourceError(cause)) throw cause;
+			if (process.env.NODE_ENV !== "production") console.error(`[react-layout] lazy "${options.label}" failed to load`, cause);
+			throw new require_resource_state_error.ResourceModuleLoadError(options.label, cause);
+		}).then(options.select).then((selected) => {
+			if (attempt === generation) {
+				status = "resolved";
+				options.hooks?.onLoadSuccess?.();
+			}
+			return selected;
+		}, (error) => {
+			if (attempt === generation) {
+				status = "error";
+				options.hooks?.onLoadError?.(error);
+			}
+			throw error;
+		});
+		return promise;
+	}
+	return {
+		get,
+		get status() {
+			return status;
+		},
+		preload: () => preloadPromise ??= get().then(() => void 0),
+		reset() {
+			generation++;
+			promise = void 0;
+			preloadPromise = void 0;
+			components.clear();
+			status = "unresolved";
+		},
+		component(member, map) {
+			const key = map ?? member;
+			let component = components.get(key);
+			if (!component) {
+				component = (0, react.lazy)(async () => {
+					const attempt = generation;
+					const selected = await get();
+					try {
+						const candidate = map ? map(selected) : member === void 0 ? selected : selected[member];
+						if (typeof candidate !== "function") throw new require_lazy_resource_error.LazyResourceStateNotFoundError(options.label, String(member));
+						return { default: candidate };
+					} catch (error) {
+						if (attempt === generation && require_lazy_resource_error.isLazyResourceError(error)) {
+							status = "error";
+							options.hooks?.onLoadError?.(error);
+						}
+						throw error;
+					}
+				});
+				components.set(key, component);
+			}
+			return component;
+		}
+	};
+}
+
+//#endregion
+exports.createLazyLoader = createLazyLoader;
+//# sourceMappingURL=create-lazy-loader.cjs.map

package/dist/lazy/create-lazy-loader.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-lazy-loader.cjs","names":["isLazyResourceError","ResourceModuleLoadError","LazyResourceStateNotFoundError"],"sources":["../../src/lazy/create-lazy-loader.ts"],"sourcesContent":["import { lazy, type ComponentType } from 'react';\nimport { ResourceModuleLoadError } from '../errors/resource-state-error';\nimport {\n  LazyResourceStateNotFoundError,\n  isLazyResourceError,\n  type LazyResourceError,\n} from '../errors/lazy-resource-error';\nimport type { LazyHandle, LoadStatus } from './types';\n\nexport type LazyResourceLoadHooks = {\n  onLoadStart?: () => void;\n  onLoadSuccess?: () => void;\n  onLoadError?: (error: LazyResourceError) => void;\n  onMount?: () => (() => void) | undefined;\n};\n\nexport type LazyLoader<Selected> = LazyHandle & {\n  get(): Promise<Selected>;\n  reset(): void;\n  component(\n    member?: PropertyKey,\n    map?: (selected: Selected) => ComponentType<any>,\n  ): ComponentType<any>;\n};\n\n/** A single import cache and lifecycle shared by every lazy entry point. */\nexport function createLazyLoader<Module, Selected>(options: {\n  load: () => Promise<Module>;\n  select: (module: Module) => Selected | Promise<Selected>;\n  label: string;\n  hooks?: LazyResourceLoadHooks;\n}): LazyLoader<Selected> {\n  let promise: Promise<Selected> | undefined;\n  let preloadPromise: Promise<void> | undefined;\n  let status: LoadStatus = 'unresolved';\n  const components = new Map<unknown, ComponentType<any>>();\n  let generation = 0;\n\n  function get() {\n    if (promise) return promise;\n    const attempt = generation;\n    status = 'loading';\n    options.hooks?.onLoadStart?.();\n    promise = Promise.resolve()\n      .then(options.load)\n      .catch((cause: unknown) => {\n        if (isLazyResourceError(cause)) throw cause;\n        if (process.env.NODE_ENV !== 'production') {\n          console.error(\n            `[react-layout] lazy \"${options.label}\" failed to load`,\n            cause,\n          );\n        }\n        throw new ResourceModuleLoadError(options.label, cause);\n      })\n      .then(options.select)\n      .then(\n        (selected) => {\n          if (attempt === generation) {\n            status = 'resolved';\n            options.hooks?.onLoadSuccess?.();\n          }\n          return selected;\n        },\n        (error: LazyResourceError) => {\n          if (attempt === generation) {\n            status = 'error';\n            options.hooks?.onLoadError?.(error);\n          }\n          throw error;\n        },\n      );\n    return promise;\n  }\n\n  return {\n    get,\n    get status() {\n      return status;\n    },\n    preload: () => (preloadPromise ??= get().then(() => undefined)),\n    reset() {\n      generation++;\n      promise = undefined;\n      preloadPromise = undefined;\n      components.clear();\n      status = 'unresolved';\n    },\n    component(member, map) {\n      const key = map ?? member;\n      let component = components.get(key);\n      if (!component) {\n        component = lazy(async () => {\n          const attempt = generation;\n          const selected = await get();\n          try {\n            const candidate = map\n              ? map(selected)\n              : member === undefined\n                ? selected\n                : (selected as Record<PropertyKey, unknown>)[member];\n            if (typeof candidate !== 'function') {\n              throw new LazyResourceStateNotFoundError(\n                options.label,\n                String(member),\n              );\n            }\n            return { default: candidate as ComponentType<any> };\n          } catch (error) {\n            if (attempt === generation && isLazyResourceError(error)) {\n              status = 'error';\n              options.hooks?.onLoadError?.(error);\n            }\n            throw error;\n          }\n        });\n        components.set(key, component);\n      }\n      return component;\n    },\n  };\n}\n"],"mappings":";;;;;;AA0BA,SAAgB,iBAAmC,SAK1B;CACvB,IAAI;CACJ,IAAI;CACJ,IAAI,SAAqB;CACzB,MAAM,6BAAa,IAAI,IAAiC;CACxD,IAAI,aAAa;CAEjB,SAAS,MAAM;EACb,IAAI,SAAS,OAAO;EACpB,MAAM,UAAU;EAChB,SAAS;EACT,QAAQ,OAAO,cAAc;EAC7B,UAAU,QAAQ,QAAQ,EACvB,KAAK,QAAQ,IAAI,EACjB,OAAO,UAAmB;GACzB,IAAIA,gDAAoB,KAAK,GAAG,MAAM;GACtC,IAAI,QAAQ,IAAI,aAAa,cAC3B,QAAQ,MACN,wBAAwB,QAAQ,MAAM,mBACtC,KACF;GAEF,MAAM,IAAIC,qDAAwB,QAAQ,OAAO,KAAK;EACxD,CAAC,EACA,KAAK,QAAQ,MAAM,EACnB,MACE,aAAa;GACZ,IAAI,YAAY,YAAY;IAC1B,SAAS;IACT,QAAQ,OAAO,gBAAgB;GACjC;GACA,OAAO;EACT,IACC,UAA6B;GAC5B,IAAI,YAAY,YAAY;IAC1B,SAAS;IACT,QAAQ,OAAO,cAAc,KAAK;GACpC;GACA,MAAM;EACR,CACF;EACF,OAAO;CACT;CAEA,OAAO;EACL;EACA,IAAI,SAAS;GACX,OAAO;EACT;EACA,eAAgB,mBAAmB,IAAI,EAAE,WAAW,MAAS;EAC7D,QAAQ;GACN;GACA,UAAU;GACV,iBAAiB;GACjB,WAAW,MAAM;GACjB,SAAS;EACX;EACA,UAAU,QAAQ,KAAK;GACrB,MAAM,MAAM,OAAO;GACnB,IAAI,YAAY,WAAW,IAAI,GAAG;GAClC,IAAI,CAAC,WAAW;IACd,4BAAiB,YAAY;KAC3B,MAAM,UAAU;KAChB,MAAM,WAAW,MAAM,IAAI;KAC3B,IAAI;MACF,MAAM,YAAY,MACd,IAAI,QAAQ,IACZ,WAAW,SACT,WACC,SAA0C;MACjD,IAAI,OAAO,cAAc,YACvB,MAAM,IAAIC,2DACR,QAAQ,OACR,OAAO,MAAM,CACf;MAEF,OAAO,EAAE,SAAS,UAAgC;KACpD,SAAS,OAAO;MACd,IAAI,YAAY,cAAcF,gDAAoB,KAAK,GAAG;OACxD,SAAS;OACT,QAAQ,OAAO,cAAc,KAAK;MACpC;MACA,MAAM;KACR;IACF,CAAC;IACD,WAAW,IAAI,KAAK,SAAS;GAC/B;GACA,OAAO;EACT;CACF;AACF"}

package/dist/lazy/create-lazy-loader.d.cts

@@ -0,0 +1,19 @@
+import { LazyResourceError } from "../errors/lazy-resource-error.cjs";
+import { LazyHandle } from "./types.cjs";
+import { ComponentType } from "react";
+
+//#region src/lazy/create-lazy-loader.d.ts
+type LazyResourceLoadHooks = {
+  onLoadStart?: () => void;
+  onLoadSuccess?: () => void;
+  onLoadError?: (error: LazyResourceError) => void;
+  onMount?: () => (() => void) | undefined;
+};
+type LazyLoader<Selected> = LazyHandle & {
+  get(): Promise<Selected>;
+  reset(): void;
+  component(member?: PropertyKey, map?: (selected: Selected) => ComponentType<any>): ComponentType<any>;
+};
+//#endregion
+export { LazyLoader, LazyResourceLoadHooks };
+//# sourceMappingURL=create-lazy-loader.d.cts.map

package/dist/lazy/create-lazy-loader.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-lazy-loader.d.cts","names":[],"sources":["../../src/lazy/create-lazy-loader.ts"],"mappings":";;;;;KASY,qBAAA;EACV,WAAA;EACA,aAAA;EACA,WAAA,IAAe,KAAA,EAAO,iBAAiB;EACvC,OAAA;AAAA;AAAA,KAGU,UAAA,aAAuB,UAAA;EACjC,GAAA,IAAO,OAAA,CAAQ,QAAA;EACf,KAAA;EACA,SAAA,CACE,MAAA,GAAS,WAAA,EACT,GAAA,IAAO,QAAA,EAAU,QAAA,KAAa,aAAA,QAC7B,aAAA;AAAA"}

package/dist/lazy/create-lazy-loader.d.mts

@@ -0,0 +1,19 @@
+import { LazyResourceError } from "../errors/lazy-resource-error.mjs";
+import { LazyHandle } from "./types.mjs";
+import { ComponentType } from "react";
+
+//#region src/lazy/create-lazy-loader.d.ts
+type LazyResourceLoadHooks = {
+  onLoadStart?: () => void;
+  onLoadSuccess?: () => void;
+  onLoadError?: (error: LazyResourceError) => void;
+  onMount?: () => (() => void) | undefined;
+};
+type LazyLoader<Selected> = LazyHandle & {
+  get(): Promise<Selected>;
+  reset(): void;
+  component(member?: PropertyKey, map?: (selected: Selected) => ComponentType<any>): ComponentType<any>;
+};
+//#endregion
+export { LazyLoader, LazyResourceLoadHooks };
+//# sourceMappingURL=create-lazy-loader.d.mts.map

package/dist/lazy/create-lazy-loader.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-lazy-loader.d.mts","names":[],"sources":["../../src/lazy/create-lazy-loader.ts"],"mappings":";;;;;KASY,qBAAA;EACV,WAAA;EACA,aAAA;EACA,WAAA,IAAe,KAAA,EAAO,iBAAiB;EACvC,OAAA;AAAA;AAAA,KAGU,UAAA,aAAuB,UAAA;EACjC,GAAA,IAAO,OAAA,CAAQ,QAAA;EACf,KAAA;EACA,SAAA,CACE,MAAA,GAAS,WAAA,EACT,GAAA,IAAO,QAAA,EAAU,QAAA,KAAa,aAAA,QAC7B,aAAA;AAAA"}

package/dist/lazy/create-lazy-loader.mjs

@@ -0,0 +1,78 @@
+import { ResourceModuleLoadError } from "../errors/resource-state-error.mjs";
+import { LazyResourceStateNotFoundError, isLazyResourceError } from "../errors/lazy-resource-error.mjs";
+import { lazy } from "react";
+
+//#region src/lazy/create-lazy-loader.ts
+/** A single import cache and lifecycle shared by every lazy entry point. */
+function createLazyLoader(options) {
+	let promise;
+	let preloadPromise;
+	let status = "unresolved";
+	const components = /* @__PURE__ */ new Map();
+	let generation = 0;
+	function get() {
+		if (promise) return promise;
+		const attempt = generation;
+		status = "loading";
+		options.hooks?.onLoadStart?.();
+		promise = Promise.resolve().then(options.load).catch((cause) => {
+			if (isLazyResourceError(cause)) throw cause;
+			if (process.env.NODE_ENV !== "production") console.error(`[react-layout] lazy "${options.label}" failed to load`, cause);
+			throw new ResourceModuleLoadError(options.label, cause);
+		}).then(options.select).then((selected) => {
+			if (attempt === generation) {
+				status = "resolved";
+				options.hooks?.onLoadSuccess?.();
+			}
+			return selected;
+		}, (error) => {
+			if (attempt === generation) {
+				status = "error";
+				options.hooks?.onLoadError?.(error);
+			}
+			throw error;
+		});
+		return promise;
+	}
+	return {
+		get,
+		get status() {
+			return status;
+		},
+		preload: () => preloadPromise ??= get().then(() => void 0),
+		reset() {
+			generation++;
+			promise = void 0;
+			preloadPromise = void 0;
+			components.clear();
+			status = "unresolved";
+		},
+		component(member, map) {
+			const key = map ?? member;
+			let component = components.get(key);
+			if (!component) {
+				component = lazy(async () => {
+					const attempt = generation;
+					const selected = await get();
+					try {
+						const candidate = map ? map(selected) : member === void 0 ? selected : selected[member];
+						if (typeof candidate !== "function") throw new LazyResourceStateNotFoundError(options.label, String(member));
+						return { default: candidate };
+					} catch (error) {
+						if (attempt === generation && isLazyResourceError(error)) {
+							status = "error";
+							options.hooks?.onLoadError?.(error);
+						}
+						throw error;
+					}
+				});
+				components.set(key, component);
+			}
+			return component;
+		}
+	};
+}
+
+//#endregion
+export { createLazyLoader };
+//# sourceMappingURL=create-lazy-loader.mjs.map

package/dist/lazy/create-lazy-loader.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-lazy-loader.mjs","names":[],"sources":["../../src/lazy/create-lazy-loader.ts"],"sourcesContent":["import { lazy, type ComponentType } from 'react';\nimport { ResourceModuleLoadError } from '../errors/resource-state-error';\nimport {\n  LazyResourceStateNotFoundError,\n  isLazyResourceError,\n  type LazyResourceError,\n} from '../errors/lazy-resource-error';\nimport type { LazyHandle, LoadStatus } from './types';\n\nexport type LazyResourceLoadHooks = {\n  onLoadStart?: () => void;\n  onLoadSuccess?: () => void;\n  onLoadError?: (error: LazyResourceError) => void;\n  onMount?: () => (() => void) | undefined;\n};\n\nexport type LazyLoader<Selected> = LazyHandle & {\n  get(): Promise<Selected>;\n  reset(): void;\n  component(\n    member?: PropertyKey,\n    map?: (selected: Selected) => ComponentType<any>,\n  ): ComponentType<any>;\n};\n\n/** A single import cache and lifecycle shared by every lazy entry point. */\nexport function createLazyLoader<Module, Selected>(options: {\n  load: () => Promise<Module>;\n  select: (module: Module) => Selected | Promise<Selected>;\n  label: string;\n  hooks?: LazyResourceLoadHooks;\n}): LazyLoader<Selected> {\n  let promise: Promise<Selected> | undefined;\n  let preloadPromise: Promise<void> | undefined;\n  let status: LoadStatus = 'unresolved';\n  const components = new Map<unknown, ComponentType<any>>();\n  let generation = 0;\n\n  function get() {\n    if (promise) return promise;\n    const attempt = generation;\n    status = 'loading';\n    options.hooks?.onLoadStart?.();\n    promise = Promise.resolve()\n      .then(options.load)\n      .catch((cause: unknown) => {\n        if (isLazyResourceError(cause)) throw cause;\n        if (process.env.NODE_ENV !== 'production') {\n          console.error(\n            `[react-layout] lazy \"${options.label}\" failed to load`,\n            cause,\n          );\n        }\n        throw new ResourceModuleLoadError(options.label, cause);\n      })\n      .then(options.select)\n      .then(\n        (selected) => {\n          if (attempt === generation) {\n            status = 'resolved';\n            options.hooks?.onLoadSuccess?.();\n          }\n          return selected;\n        },\n        (error: LazyResourceError) => {\n          if (attempt === generation) {\n            status = 'error';\n            options.hooks?.onLoadError?.(error);\n          }\n          throw error;\n        },\n      );\n    return promise;\n  }\n\n  return {\n    get,\n    get status() {\n      return status;\n    },\n    preload: () => (preloadPromise ??= get().then(() => undefined)),\n    reset() {\n      generation++;\n      promise = undefined;\n      preloadPromise = undefined;\n      components.clear();\n      status = 'unresolved';\n    },\n    component(member, map) {\n      const key = map ?? member;\n      let component = components.get(key);\n      if (!component) {\n        component = lazy(async () => {\n          const attempt = generation;\n          const selected = await get();\n          try {\n            const candidate = map\n              ? map(selected)\n              : member === undefined\n                ? selected\n                : (selected as Record<PropertyKey, unknown>)[member];\n            if (typeof candidate !== 'function') {\n              throw new LazyResourceStateNotFoundError(\n                options.label,\n                String(member),\n              );\n            }\n            return { default: candidate as ComponentType<any> };\n          } catch (error) {\n            if (attempt === generation && isLazyResourceError(error)) {\n              status = 'error';\n              options.hooks?.onLoadError?.(error);\n            }\n            throw error;\n          }\n        });\n        components.set(key, component);\n      }\n      return component;\n    },\n  };\n}\n"],"mappings":";;;;;;AA0BA,SAAgB,iBAAmC,SAK1B;CACvB,IAAI;CACJ,IAAI;CACJ,IAAI,SAAqB;CACzB,MAAM,6BAAa,IAAI,IAAiC;CACxD,IAAI,aAAa;CAEjB,SAAS,MAAM;EACb,IAAI,SAAS,OAAO;EACpB,MAAM,UAAU;EAChB,SAAS;EACT,QAAQ,OAAO,cAAc;EAC7B,UAAU,QAAQ,QAAQ,EACvB,KAAK,QAAQ,IAAI,EACjB,OAAO,UAAmB;GACzB,IAAI,oBAAoB,KAAK,GAAG,MAAM;GACtC,IAAI,QAAQ,IAAI,aAAa,cAC3B,QAAQ,MACN,wBAAwB,QAAQ,MAAM,mBACtC,KACF;GAEF,MAAM,IAAI,wBAAwB,QAAQ,OAAO,KAAK;EACxD,CAAC,EACA,KAAK,QAAQ,MAAM,EACnB,MACE,aAAa;GACZ,IAAI,YAAY,YAAY;IAC1B,SAAS;IACT,QAAQ,OAAO,gBAAgB;GACjC;GACA,OAAO;EACT,IACC,UAA6B;GAC5B,IAAI,YAAY,YAAY;IAC1B,SAAS;IACT,QAAQ,OAAO,cAAc,KAAK;GACpC;GACA,MAAM;EACR,CACF;EACF,OAAO;CACT;CAEA,OAAO;EACL;EACA,IAAI,SAAS;GACX,OAAO;EACT;EACA,eAAgB,mBAAmB,IAAI,EAAE,WAAW,MAAS;EAC7D,QAAQ;GACN;GACA,UAAU;GACV,iBAAiB;GACjB,WAAW,MAAM;GACjB,SAAS;EACX;EACA,UAAU,QAAQ,KAAK;GACrB,MAAM,MAAM,OAAO;GACnB,IAAI,YAAY,WAAW,IAAI,GAAG;GAClC,IAAI,CAAC,WAAW;IACd,YAAY,KAAK,YAAY;KAC3B,MAAM,UAAU;KAChB,MAAM,WAAW,MAAM,IAAI;KAC3B,IAAI;MACF,MAAM,YAAY,MACd,IAAI,QAAQ,IACZ,WAAW,SACT,WACC,SAA0C;MACjD,IAAI,OAAO,cAAc,YACvB,MAAM,IAAI,+BACR,QAAQ,OACR,OAAO,MAAM,CACf;MAEF,OAAO,EAAE,SAAS,UAAgC;KACpD,SAAS,OAAO;MACd,IAAI,YAAY,cAAc,oBAAoB,KAAK,GAAG;OACxD,SAAS;OACT,QAAQ,OAAO,cAAc,KAAK;MACpC;MACA,MAAM;KACR;IACF,CAAC;IACD,WAAW,IAAI,KAAK,SAAS;GAC/B;GACA,OAAO;EACT;CACF;AACF"}

package/dist/lazy/create-render-state.cjs

@@ -0,0 +1,59 @@
+const require_layout_configuration_error = require('../errors/layout-configuration-error.cjs');
+const require_define_layout = require('../create-config/define-layout.cjs');
+let react = require("react");
+
+//#region src/lazy/create-render-state.tsx
+function createLazyRenderStateBuilder(configuration) {
+	function createRenderState(definition) {
+		if (definition.state !== "Loading" && definition.state !== "Error") throw new require_layout_configuration_error.LayoutConfigurationError(`Unknown lazy default state "${definition.state}"`);
+		const include = Object.fromEntries(Object.entries(definition.props?.include ?? {}).map(([key, behavior]) => [key, behavior === true ? {
+			required: true,
+			suppliedVia: "component"
+		} : behavior]));
+		function RenderLazyDefault({ props, context }) {
+			if (typeof definition.render === "function") return definition.render(props, context);
+			const errorProps = props;
+			const handler = definition.render[errorProps.error.code] ?? definition.render.fallback;
+			if (!handler) throw errorProps.error;
+			return handler(props, context);
+		}
+		const layout = require_define_layout.defineResourceLayout({
+			resources: configuration.resources,
+			options: configuration.options,
+			layout: { render: {
+				default: () => null,
+				[definition.state]: {
+					composables: configuration.composables,
+					props: {
+						include,
+						custom: definition.props?.custom
+					},
+					render: (props, context) => (0, react.createElement)(RenderLazyDefault, {
+						props,
+						context
+					})
+				}
+			} }
+		});
+		const components = /* @__PURE__ */ new Map();
+		function LazyDefault(props) {
+			const resource = props.resource.split(".")[0];
+			let Component = components.get(resource);
+			if (!Component) {
+				Component = layout.createResourceLayout({
+					resource,
+					name: "LazyDefault",
+					namespace: false
+				})[definition.state];
+				components.set(resource, Component);
+			}
+			return (0, react.createElement)(Component, props);
+		}
+		return LazyDefault;
+	}
+	return createRenderState;
+}
+
+//#endregion
+exports.createLazyRenderStateBuilder = createLazyRenderStateBuilder;
+//# sourceMappingURL=create-render-state.cjs.map

package/dist/lazy/create-render-state.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-render-state.cjs","names":["LayoutConfigurationError","defineResourceLayout"],"sources":["../../src/lazy/create-render-state.tsx"],"sourcesContent":["import { createElement, type ComponentType, type ReactNode } from 'react';\nimport type { ComposableComponents } from '@jfdevelops/react-layout-composables';\nimport { LayoutConfigurationError } from '../errors';\nimport type { ResourceDefinition, ResourcePath } from '../resource';\nimport {\n  type ResolvedIncludedComponentProps,\n  type IncludedProps,\n  type InPropsDefinition,\n  type InPropsObject,\n  type MergedLayoutInProps,\n} from '../props';\nimport { defineResourceLayout } from '../create-config/define-layout';\nimport type {\n  LayoutComposablesDefinition,\n  RenderStateContext,\n  RenderStateProps,\n  OptionalStateChildren,\n} from '../create-config/render-state';\nimport type { ResolveProps } from '@jfdevelops/react-layout-validator';\nimport type {\n  LazyResourceErrorProps,\n  LazyErrorHandlers,\n  CreateLazyErrorComponent,\n} from './types';\n\nexport type LazyDefaultState = 'Loading' | 'Error';\ntype BuiltinProps<\n  State extends LazyDefaultState,\n  Resource,\n> = State extends 'Error'\n  ? LazyResourceErrorProps<Resource>\n  : { resource: Resource };\n\n/** Shorthand includes are direct props; explicit supply sources retain their contract. */\ntype LazyDefaultIncludes<Include> = {\n  [Key in keyof Include]: Include[Key] extends true\n    ? { required: true; suppliedVia: 'component' }\n    : Include[Key];\n};\n\ntype LazyRender<State extends LazyDefaultState, Resource, Props, Context> =\n  | ((\n      props: Props & BuiltinProps<State, Resource>,\n      context: Context,\n    ) => ReactNode)\n  | (State extends 'Error'\n      ? LazyErrorHandlers<Resource, Props & object, Context>\n      : never);\n\n/** Creates validated, composable-aware fallback components for one factory. */\nexport type CreateLazyRenderState<\n  Resources extends ReadonlyArray<ResourceDefinition>,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n> = <\n  const State extends LazyDefaultState,\n  const Custom extends InPropsObject = {},\n  const Include extends IncludedProps<\n    MergedLayoutInProps<Resources, Options, Composables>\n  > = {},\n>(definition: {\n  state: State;\n  props?: { include?: Include; custom?: Custom };\n  render: LazyRender<State, ResourcePath<Resources>, RenderStateProps<Resources, Options, Composables, Include, Custom>, RenderStateContext<Composables, Resources, State>>;\n}) => ComponentType<\n  OptionalStateChildren<\n    ResolveProps<Custom> &\n      ResolvedIncludedComponentProps<\n        MergedLayoutInProps<Resources, Options, Composables>,\n        LazyDefaultIncludes<Include>\n      >\n  > &\n    BuiltinProps<State, ResourcePath<Resources>>\n>;\n\n/** Compatibility helper; custom props keep their existing unchecked contract. */\nexport type CreateBoundLazyErrorComponent<Resource, Context> =\n  CreateLazyErrorComponent<Resource, Context>;\n\ntype RuntimeDefinition = {\n  state: LazyDefaultState;\n  props?: { include?: Record<string, unknown>; custom?: InPropsObject };\n  render:\n    | ((props: any, context: any) => ReactNode)\n    | LazyErrorHandlers<string, object, any>;\n};\n\nexport function createLazyRenderStateBuilder<\n  Resources extends ReadonlyArray<ResourceDefinition>,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n>(configuration: {\n  resources: Resources;\n  options: Options;\n  composables?: LayoutComposablesDefinition<Resources, Composables>;\n}): CreateLazyRenderState<Resources, Options, Composables> {\n  function createRenderState(definition: RuntimeDefinition) {\n    if (definition.state !== 'Loading' && definition.state !== 'Error') {\n      throw new LayoutConfigurationError(\n        `Unknown lazy default state \"${definition.state}\"`,\n      );\n    }\n    // Lazy defaults have no create-time configuration call. Included values are\n    // supplied by their component caller unless an explicit config source is selected.\n    const include = Object.fromEntries(\n      Object.entries(definition.props?.include ?? {}).map(([key, behavior]) => [\n        key,\n        behavior === true\n          ? { required: true, suppliedVia: 'component' }\n          : behavior,\n      ]),\n    );\n    function RenderLazyDefault({\n      props,\n      context,\n    }: {\n      props: any;\n      context: any;\n    }) {\n      if (typeof definition.render === 'function') {\n        return definition.render(props, context);\n      }\n      const errorProps = props as LazyResourceErrorProps;\n      const handler =\n        definition.render[errorProps.error.code] ?? definition.render.fallback;\n      if (!handler) throw errorProps.error;\n      return handler(props as never, context);\n    }\n    const layout = defineResourceLayout({\n      resources: configuration.resources,\n      options: configuration.options,\n      layout: {\n        render: {\n          default: () => null,\n          [definition.state]: {\n            composables: configuration.composables,\n            props: { include, custom: definition.props?.custom },\n            render: (props: any, context: any) =>\n              createElement(RenderLazyDefault, { props, context }),\n          },\n        },\n      },\n    } as never);\n    const components = new Map<string, ComponentType<any>>();\n    function LazyDefault(props: { resource: string }) {\n      // Nested lazy paths use the factory's top-level resource definitions for\n      // option resolution. The callback still receives the complete path.\n      const resource = props.resource.split('.')[0]!;\n      let Component = components.get(resource);\n      if (!Component) {\n        const Root = layout.createResourceLayout({\n          resource,\n          name: 'LazyDefault',\n          namespace: false,\n        } as never) as unknown as Record<LazyDefaultState, ComponentType<any>>;\n        Component = Root[definition.state];\n        components.set(resource, Component);\n      }\n      return createElement(Component, props);\n    }\n    return LazyDefault;\n  }\n  return createRenderState as CreateLazyRenderState<\n    Resources,\n    Options,\n    Composables\n  >;\n}\n"],"mappings":";;;;;AAuFA,SAAgB,6BAId,eAIyD;CACzD,SAAS,kBAAkB,YAA+B;EACxD,IAAI,WAAW,UAAU,aAAa,WAAW,UAAU,SACzD,MAAM,IAAIA,4DACR,+BAA+B,WAAW,MAAM,EAClD;EAIF,MAAM,UAAU,OAAO,YACrB,OAAO,QAAQ,WAAW,OAAO,WAAW,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,cAAc,CACvE,KACA,aAAa,OACT;GAAE,UAAU;GAAM,aAAa;EAAY,IAC3C,QACN,CAAC,CACH;EACA,SAAS,kBAAkB,EACzB,OACA,WAIC;GACD,IAAI,OAAO,WAAW,WAAW,YAC/B,OAAO,WAAW,OAAO,OAAO,OAAO;GAEzC,MAAM,aAAa;GACnB,MAAM,UACJ,WAAW,OAAO,WAAW,MAAM,SAAS,WAAW,OAAO;GAChE,IAAI,CAAC,SAAS,MAAM,WAAW;GAC/B,OAAO,QAAQ,OAAgB,OAAO;EACxC;EACA,MAAM,SAASC,2CAAqB;GAClC,WAAW,cAAc;GACzB,SAAS,cAAc;GACvB,QAAQ,EACN,QAAQ;IACN,eAAe;KACd,WAAW,QAAQ;KAClB,aAAa,cAAc;KAC3B,OAAO;MAAE;MAAS,QAAQ,WAAW,OAAO;KAAO;KACnD,SAAS,OAAY,qCACL,mBAAmB;MAAE;MAAO;KAAQ,CAAC;IACvD;GACF,EACF;EACF,CAAU;EACV,MAAM,6BAAa,IAAI,IAAgC;EACvD,SAAS,YAAY,OAA6B;GAGhD,MAAM,WAAW,MAAM,SAAS,MAAM,GAAG,EAAE;GAC3C,IAAI,YAAY,WAAW,IAAI,QAAQ;GACvC,IAAI,CAAC,WAAW;IAMd,YALa,OAAO,qBAAqB;KACvC;KACA,MAAM;KACN,WAAW;IACb,CACe,EAAE,WAAW;IAC5B,WAAW,IAAI,UAAU,SAAS;GACpC;GACA,gCAAqB,WAAW,KAAK;EACvC;EACA,OAAO;CACT;CACA,OAAO;AAKT"}

package/dist/lazy/create-render-state.d.cts

@@ -0,0 +1,33 @@
+import { CreateLazyErrorComponent, LazyErrorHandlers, LazyResourceErrorProps } from "./types.cjs";
+import { ResourceDefinition, ResourcePath } from "../resource.cjs";
+import { InPropsDefinition, InPropsObject, IncludedProps, MergedLayoutInProps, ResolvedIncludedComponentProps } from "../props.cjs";
+import { OptionalStateChildren, RenderStateContext, RenderStateProps } from "../create-config/render-state.cjs";
+import { ComposableComponents } from "@jfdevelops/react-layout-composables";
+import { ComponentType, ReactNode } from "react";
+import { ResolveProps } from "@jfdevelops/react-layout-validator";
+
+//#region src/lazy/create-render-state.d.ts
+type LazyDefaultState = 'Loading' | 'Error';
+type BuiltinProps<State extends LazyDefaultState, Resource> = State extends 'Error' ? LazyResourceErrorProps<Resource> : {
+  resource: Resource;
+};
+/** Shorthand includes are direct props; explicit supply sources retain their contract. */
+type LazyDefaultIncludes<Include> = { [Key in keyof Include]: Include[Key] extends true ? {
+  required: true;
+  suppliedVia: 'component';
+} : Include[Key] };
+type LazyRender<State extends LazyDefaultState, Resource, Props, Context> = ((props: Props & BuiltinProps<State, Resource>, context: Context) => ReactNode) | (State extends 'Error' ? LazyErrorHandlers<Resource, Props & object, Context> : never);
+/** Creates validated, composable-aware fallback components for one factory. */
+type CreateLazyRenderState<Resources extends ReadonlyArray<ResourceDefinition>, Options extends InPropsDefinition<Resources>, Composables extends ComposableComponents> = <const State extends LazyDefaultState, const Custom extends InPropsObject = {}, const Include extends IncludedProps<MergedLayoutInProps<Resources, Options, Composables>> = {}>(definition: {
+  state: State;
+  props?: {
+    include?: Include;
+    custom?: Custom;
+  };
+  render: LazyRender<State, ResourcePath<Resources>, RenderStateProps<Resources, Options, Composables, Include, Custom>, RenderStateContext<Composables, Resources, State>>;
+}) => ComponentType<OptionalStateChildren<ResolveProps<Custom> & ResolvedIncludedComponentProps<MergedLayoutInProps<Resources, Options, Composables>, LazyDefaultIncludes<Include>>> & BuiltinProps<State, ResourcePath<Resources>>>;
+/** Compatibility helper; custom props keep their existing unchecked contract. */
+type CreateBoundLazyErrorComponent<Resource, Context> = CreateLazyErrorComponent<Resource, Context>;
+//#endregion
+export { CreateBoundLazyErrorComponent, CreateLazyRenderState, LazyDefaultState };
+//# sourceMappingURL=create-render-state.d.cts.map

package/dist/lazy/create-render-state.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-render-state.d.cts","names":[],"sources":["../../src/lazy/create-render-state.tsx"],"mappings":";;;;;;;;;KAyBY,gBAAA;AAAA,KACP,YAAA,eACW,gBAAA,cAEZ,KAAA,mBACA,sBAAA,CAAuB,QAAA;EACrB,QAAA,EAAU,QAAA;AAAA;;KAGX,mBAAA,4BACW,OAAA,GAAU,OAAA,CAAQ,GAAA;EAC1B,QAAA;EAAgB,WAAA;AAAA,IAClB,OAAA,CAAQ,GAAA;AAAA,KAGT,UAAA,eAAyB,gBAAA,gCAExB,KAAA,EAAO,KAAA,GAAQ,YAAA,CAAa,KAAA,EAAO,QAAA,GACnC,OAAA,EAAS,OAAA,KACN,SAAA,KACJ,KAAA,mBACG,iBAAA,CAAkB,QAAA,EAAU,KAAA,WAAgB,OAAA;;KAIxC,qBAAA,mBACQ,aAAA,CAAc,kBAAA,mBAChB,iBAAA,CAAkB,SAAA,uBACd,oBAAA,yBAEA,gBAAA,uBACC,aAAA,6BACC,aAAA,CACpB,mBAAA,CAAoB,SAAA,EAAW,OAAA,EAAS,WAAA,SAE1C,UAAA;EACA,KAAA,EAAO,KAAA;EACP,KAAA;IAAU,OAAA,GAAU,OAAA;IAAS,MAAA,GAAS,MAAA;EAAA;EACtC,MAAA,EAAQ,UAAA,CAAW,KAAA,EAAO,YAAA,CAAa,SAAA,GAAY,gBAAA,CAAiB,SAAA,EAAW,OAAA,EAAS,WAAA,EAAa,OAAA,EAAS,MAAA,GAAS,kBAAA,CAAmB,WAAA,EAAa,SAAA,EAAW,KAAA;AAAA,MAC9J,aAAA,CACJ,qBAAA,CACE,YAAA,CAAa,MAAA,IACX,8BAAA,CACE,mBAAA,CAAoB,SAAA,EAAW,OAAA,EAAS,WAAA,GACxC,mBAAA,CAAoB,OAAA,MAGxB,YAAA,CAAa,KAAA,EAAO,YAAA,CAAa,SAAA;;KAIzB,6BAAA,sBACV,wBAAA,CAAyB,QAAA,EAAU,OAAA"}

package/dist/lazy/create-render-state.d.mts

@@ -0,0 +1,33 @@
+import { CreateLazyErrorComponent, LazyErrorHandlers, LazyResourceErrorProps } from "./types.mjs";
+import { ResourceDefinition, ResourcePath } from "../resource.mjs";
+import { InPropsDefinition, InPropsObject, IncludedProps, MergedLayoutInProps, ResolvedIncludedComponentProps } from "../props.mjs";
+import { OptionalStateChildren, RenderStateContext, RenderStateProps } from "../create-config/render-state.mjs";
+import { ComposableComponents } from "@jfdevelops/react-layout-composables";
+import { ComponentType, ReactNode } from "react";
+import { ResolveProps } from "@jfdevelops/react-layout-validator";
+
+//#region src/lazy/create-render-state.d.ts
+type LazyDefaultState = 'Loading' | 'Error';
+type BuiltinProps<State extends LazyDefaultState, Resource> = State extends 'Error' ? LazyResourceErrorProps<Resource> : {
+  resource: Resource;
+};
+/** Shorthand includes are direct props; explicit supply sources retain their contract. */
+type LazyDefaultIncludes<Include> = { [Key in keyof Include]: Include[Key] extends true ? {
+  required: true;
+  suppliedVia: 'component';
+} : Include[Key] };
+type LazyRender<State extends LazyDefaultState, Resource, Props, Context> = ((props: Props & BuiltinProps<State, Resource>, context: Context) => ReactNode) | (State extends 'Error' ? LazyErrorHandlers<Resource, Props & object, Context> : never);
+/** Creates validated, composable-aware fallback components for one factory. */
+type CreateLazyRenderState<Resources extends ReadonlyArray<ResourceDefinition>, Options extends InPropsDefinition<Resources>, Composables extends ComposableComponents> = <const State extends LazyDefaultState, const Custom extends InPropsObject = {}, const Include extends IncludedProps<MergedLayoutInProps<Resources, Options, Composables>> = {}>(definition: {
+  state: State;
+  props?: {
+    include?: Include;
+    custom?: Custom;
+  };
+  render: LazyRender<State, ResourcePath<Resources>, RenderStateProps<Resources, Options, Composables, Include, Custom>, RenderStateContext<Composables, Resources, State>>;
+}) => ComponentType<OptionalStateChildren<ResolveProps<Custom> & ResolvedIncludedComponentProps<MergedLayoutInProps<Resources, Options, Composables>, LazyDefaultIncludes<Include>>> & BuiltinProps<State, ResourcePath<Resources>>>;
+/** Compatibility helper; custom props keep their existing unchecked contract. */
+type CreateBoundLazyErrorComponent<Resource, Context> = CreateLazyErrorComponent<Resource, Context>;
+//#endregion
+export { CreateBoundLazyErrorComponent, CreateLazyRenderState, LazyDefaultState };
+//# sourceMappingURL=create-render-state.d.mts.map

package/dist/lazy/create-render-state.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-render-state.d.mts","names":[],"sources":["../../src/lazy/create-render-state.tsx"],"mappings":";;;;;;;;;KAyBY,gBAAA;AAAA,KACP,YAAA,eACW,gBAAA,cAEZ,KAAA,mBACA,sBAAA,CAAuB,QAAA;EACrB,QAAA,EAAU,QAAA;AAAA;;KAGX,mBAAA,4BACW,OAAA,GAAU,OAAA,CAAQ,GAAA;EAC1B,QAAA;EAAgB,WAAA;AAAA,IAClB,OAAA,CAAQ,GAAA;AAAA,KAGT,UAAA,eAAyB,gBAAA,gCAExB,KAAA,EAAO,KAAA,GAAQ,YAAA,CAAa,KAAA,EAAO,QAAA,GACnC,OAAA,EAAS,OAAA,KACN,SAAA,KACJ,KAAA,mBACG,iBAAA,CAAkB,QAAA,EAAU,KAAA,WAAgB,OAAA;;KAIxC,qBAAA,mBACQ,aAAA,CAAc,kBAAA,mBAChB,iBAAA,CAAkB,SAAA,uBACd,oBAAA,yBAEA,gBAAA,uBACC,aAAA,6BACC,aAAA,CACpB,mBAAA,CAAoB,SAAA,EAAW,OAAA,EAAS,WAAA,SAE1C,UAAA;EACA,KAAA,EAAO,KAAA;EACP,KAAA;IAAU,OAAA,GAAU,OAAA;IAAS,MAAA,GAAS,MAAA;EAAA;EACtC,MAAA,EAAQ,UAAA,CAAW,KAAA,EAAO,YAAA,CAAa,SAAA,GAAY,gBAAA,CAAiB,SAAA,EAAW,OAAA,EAAS,WAAA,EAAa,OAAA,EAAS,MAAA,GAAS,kBAAA,CAAmB,WAAA,EAAa,SAAA,EAAW,KAAA;AAAA,MAC9J,aAAA,CACJ,qBAAA,CACE,YAAA,CAAa,MAAA,IACX,8BAAA,CACE,mBAAA,CAAoB,SAAA,EAAW,OAAA,EAAS,WAAA,GACxC,mBAAA,CAAoB,OAAA,MAGxB,YAAA,CAAa,KAAA,EAAO,YAAA,CAAa,SAAA;;KAIzB,6BAAA,sBACV,wBAAA,CAAyB,QAAA,EAAU,OAAA"}

package/dist/lazy/create-render-state.mjs

@@ -0,0 +1,59 @@
+import { LayoutConfigurationError } from "../errors/layout-configuration-error.mjs";
+import { defineResourceLayout } from "../create-config/define-layout.mjs";
+import { createElement } from "react";
+
+//#region src/lazy/create-render-state.tsx
+function createLazyRenderStateBuilder(configuration) {
+	function createRenderState(definition) {
+		if (definition.state !== "Loading" && definition.state !== "Error") throw new LayoutConfigurationError(`Unknown lazy default state "${definition.state}"`);
+		const include = Object.fromEntries(Object.entries(definition.props?.include ?? {}).map(([key, behavior]) => [key, behavior === true ? {
+			required: true,
+			suppliedVia: "component"
+		} : behavior]));
+		function RenderLazyDefault({ props, context }) {
+			if (typeof definition.render === "function") return definition.render(props, context);
+			const errorProps = props;
+			const handler = definition.render[errorProps.error.code] ?? definition.render.fallback;
+			if (!handler) throw errorProps.error;
+			return handler(props, context);
+		}
+		const layout = defineResourceLayout({
+			resources: configuration.resources,
+			options: configuration.options,
+			layout: { render: {
+				default: () => null,
+				[definition.state]: {
+					composables: configuration.composables,
+					props: {
+						include,
+						custom: definition.props?.custom
+					},
+					render: (props, context) => createElement(RenderLazyDefault, {
+						props,
+						context
+					})
+				}
+			} }
+		});
+		const components = /* @__PURE__ */ new Map();
+		function LazyDefault(props) {
+			const resource = props.resource.split(".")[0];
+			let Component = components.get(resource);
+			if (!Component) {
+				Component = layout.createResourceLayout({
+					resource,
+					name: "LazyDefault",
+					namespace: false
+				})[definition.state];
+				components.set(resource, Component);
+			}
+			return createElement(Component, props);
+		}
+		return LazyDefault;
+	}
+	return createRenderState;
+}
+
+//#endregion
+export { createLazyRenderStateBuilder };
+//# sourceMappingURL=create-render-state.mjs.map

package/dist/lazy/create-render-state.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-render-state.mjs","names":[],"sources":["../../src/lazy/create-render-state.tsx"],"sourcesContent":["import { createElement, type ComponentType, type ReactNode } from 'react';\nimport type { ComposableComponents } from '@jfdevelops/react-layout-composables';\nimport { LayoutConfigurationError } from '../errors';\nimport type { ResourceDefinition, ResourcePath } from '../resource';\nimport {\n  type ResolvedIncludedComponentProps,\n  type IncludedProps,\n  type InPropsDefinition,\n  type InPropsObject,\n  type MergedLayoutInProps,\n} from '../props';\nimport { defineResourceLayout } from '../create-config/define-layout';\nimport type {\n  LayoutComposablesDefinition,\n  RenderStateContext,\n  RenderStateProps,\n  OptionalStateChildren,\n} from '../create-config/render-state';\nimport type { ResolveProps } from '@jfdevelops/react-layout-validator';\nimport type {\n  LazyResourceErrorProps,\n  LazyErrorHandlers,\n  CreateLazyErrorComponent,\n} from './types';\n\nexport type LazyDefaultState = 'Loading' | 'Error';\ntype BuiltinProps<\n  State extends LazyDefaultState,\n  Resource,\n> = State extends 'Error'\n  ? LazyResourceErrorProps<Resource>\n  : { resource: Resource };\n\n/** Shorthand includes are direct props; explicit supply sources retain their contract. */\ntype LazyDefaultIncludes<Include> = {\n  [Key in keyof Include]: Include[Key] extends true\n    ? { required: true; suppliedVia: 'component' }\n    : Include[Key];\n};\n\ntype LazyRender<State extends LazyDefaultState, Resource, Props, Context> =\n  | ((\n      props: Props & BuiltinProps<State, Resource>,\n      context: Context,\n    ) => ReactNode)\n  | (State extends 'Error'\n      ? LazyErrorHandlers<Resource, Props & object, Context>\n      : never);\n\n/** Creates validated, composable-aware fallback components for one factory. */\nexport type CreateLazyRenderState<\n  Resources extends ReadonlyArray<ResourceDefinition>,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n> = <\n  const State extends LazyDefaultState,\n  const Custom extends InPropsObject = {},\n  const Include extends IncludedProps<\n    MergedLayoutInProps<Resources, Options, Composables>\n  > = {},\n>(definition: {\n  state: State;\n  props?: { include?: Include; custom?: Custom };\n  render: LazyRender<State, ResourcePath<Resources>, RenderStateProps<Resources, Options, Composables, Include, Custom>, RenderStateContext<Composables, Resources, State>>;\n}) => ComponentType<\n  OptionalStateChildren<\n    ResolveProps<Custom> &\n      ResolvedIncludedComponentProps<\n        MergedLayoutInProps<Resources, Options, Composables>,\n        LazyDefaultIncludes<Include>\n      >\n  > &\n    BuiltinProps<State, ResourcePath<Resources>>\n>;\n\n/** Compatibility helper; custom props keep their existing unchecked contract. */\nexport type CreateBoundLazyErrorComponent<Resource, Context> =\n  CreateLazyErrorComponent<Resource, Context>;\n\ntype RuntimeDefinition = {\n  state: LazyDefaultState;\n  props?: { include?: Record<string, unknown>; custom?: InPropsObject };\n  render:\n    | ((props: any, context: any) => ReactNode)\n    | LazyErrorHandlers<string, object, any>;\n};\n\nexport function createLazyRenderStateBuilder<\n  Resources extends ReadonlyArray<ResourceDefinition>,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n>(configuration: {\n  resources: Resources;\n  options: Options;\n  composables?: LayoutComposablesDefinition<Resources, Composables>;\n}): CreateLazyRenderState<Resources, Options, Composables> {\n  function createRenderState(definition: RuntimeDefinition) {\n    if (definition.state !== 'Loading' && definition.state !== 'Error') {\n      throw new LayoutConfigurationError(\n        `Unknown lazy default state \"${definition.state}\"`,\n      );\n    }\n    // Lazy defaults have no create-time configuration call. Included values are\n    // supplied by their component caller unless an explicit config source is selected.\n    const include = Object.fromEntries(\n      Object.entries(definition.props?.include ?? {}).map(([key, behavior]) => [\n        key,\n        behavior === true\n          ? { required: true, suppliedVia: 'component' }\n          : behavior,\n      ]),\n    );\n    function RenderLazyDefault({\n      props,\n      context,\n    }: {\n      props: any;\n      context: any;\n    }) {\n      if (typeof definition.render === 'function') {\n        return definition.render(props, context);\n      }\n      const errorProps = props as LazyResourceErrorProps;\n      const handler =\n        definition.render[errorProps.error.code] ?? definition.render.fallback;\n      if (!handler) throw errorProps.error;\n      return handler(props as never, context);\n    }\n    const layout = defineResourceLayout({\n      resources: configuration.resources,\n      options: configuration.options,\n      layout: {\n        render: {\n          default: () => null,\n          [definition.state]: {\n            composables: configuration.composables,\n            props: { include, custom: definition.props?.custom },\n            render: (props: any, context: any) =>\n              createElement(RenderLazyDefault, { props, context }),\n          },\n        },\n      },\n    } as never);\n    const components = new Map<string, ComponentType<any>>();\n    function LazyDefault(props: { resource: string }) {\n      // Nested lazy paths use the factory's top-level resource definitions for\n      // option resolution. The callback still receives the complete path.\n      const resource = props.resource.split('.')[0]!;\n      let Component = components.get(resource);\n      if (!Component) {\n        const Root = layout.createResourceLayout({\n          resource,\n          name: 'LazyDefault',\n          namespace: false,\n        } as never) as unknown as Record<LazyDefaultState, ComponentType<any>>;\n        Component = Root[definition.state];\n        components.set(resource, Component);\n      }\n      return createElement(Component, props);\n    }\n    return LazyDefault;\n  }\n  return createRenderState as CreateLazyRenderState<\n    Resources,\n    Options,\n    Composables\n  >;\n}\n"],"mappings":";;;;;AAuFA,SAAgB,6BAId,eAIyD;CACzD,SAAS,kBAAkB,YAA+B;EACxD,IAAI,WAAW,UAAU,aAAa,WAAW,UAAU,SACzD,MAAM,IAAI,yBACR,+BAA+B,WAAW,MAAM,EAClD;EAIF,MAAM,UAAU,OAAO,YACrB,OAAO,QAAQ,WAAW,OAAO,WAAW,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,cAAc,CACvE,KACA,aAAa,OACT;GAAE,UAAU;GAAM,aAAa;EAAY,IAC3C,QACN,CAAC,CACH;EACA,SAAS,kBAAkB,EACzB,OACA,WAIC;GACD,IAAI,OAAO,WAAW,WAAW,YAC/B,OAAO,WAAW,OAAO,OAAO,OAAO;GAEzC,MAAM,aAAa;GACnB,MAAM,UACJ,WAAW,OAAO,WAAW,MAAM,SAAS,WAAW,OAAO;GAChE,IAAI,CAAC,SAAS,MAAM,WAAW;GAC/B,OAAO,QAAQ,OAAgB,OAAO;EACxC;EACA,MAAM,SAAS,qBAAqB;GAClC,WAAW,cAAc;GACzB,SAAS,cAAc;GACvB,QAAQ,EACN,QAAQ;IACN,eAAe;KACd,WAAW,QAAQ;KAClB,aAAa,cAAc;KAC3B,OAAO;MAAE;MAAS,QAAQ,WAAW,OAAO;KAAO;KACnD,SAAS,OAAY,YACnB,cAAc,mBAAmB;MAAE;MAAO;KAAQ,CAAC;IACvD;GACF,EACF;EACF,CAAU;EACV,MAAM,6BAAa,IAAI,IAAgC;EACvD,SAAS,YAAY,OAA6B;GAGhD,MAAM,WAAW,MAAM,SAAS,MAAM,GAAG,EAAE;GAC3C,IAAI,YAAY,WAAW,IAAI,QAAQ;GACvC,IAAI,CAAC,WAAW;IAMd,YALa,OAAO,qBAAqB;KACvC;KACA,MAAM;KACN,WAAW;IACb,CACe,EAAE,WAAW;IAC5B,WAAW,IAAI,UAAU,SAAS;GACpC;GACA,OAAO,cAAc,WAAW,KAAK;EACvC;EACA,OAAO;CACT;CACA,OAAO;AAKT"}

package/dist/lazy/fallback-props.cjs

@@ -0,0 +1,9 @@
+let react = require("react");
+
+//#region src/lazy/fallback-props.ts
+/** Scoped fallbacks receive current caller options without rebuilding their layout. */
+const LazyFallbackPropsContext = (0, react.createContext)(void 0);
+
+//#endregion
+exports.LazyFallbackPropsContext = LazyFallbackPropsContext;
+//# sourceMappingURL=fallback-props.cjs.map

package/dist/lazy/fallback-props.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallback-props.cjs","names":[],"sources":["../../src/lazy/fallback-props.ts"],"sourcesContent":["import { createContext } from 'react';\n\n/** Scoped fallbacks receive current caller options without rebuilding their layout. */\nexport const LazyFallbackPropsContext = createContext<\n  { owner?: string; props: Record<string, unknown> } | undefined\n>(undefined);\n"],"mappings":";;;;AAGA,MAAa,oDAEX,MAAS"}

package/dist/lazy/fallback-props.mjs

@@ -0,0 +1,9 @@
+import { createContext } from "react";
+
+//#region src/lazy/fallback-props.ts
+/** Scoped fallbacks receive current caller options without rebuilding their layout. */
+const LazyFallbackPropsContext = createContext(void 0);
+
+//#endregion
+export { LazyFallbackPropsContext };
+//# sourceMappingURL=fallback-props.mjs.map

package/dist/lazy/fallback-props.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallback-props.mjs","names":[],"sources":["../../src/lazy/fallback-props.ts"],"sourcesContent":["import { createContext } from 'react';\n\n/** Scoped fallbacks receive current caller options without rebuilding their layout. */\nexport const LazyFallbackPropsContext = createContext<\n  { owner?: string; props: Record<string, unknown> } | undefined\n>(undefined);\n"],"mappings":";;;;AAGA,MAAa,2BAA2B,cAEtC,MAAS"}

package/dist/lazy/inspection.cjs

@@ -0,0 +1,51 @@
+let _jfdevelops_react_layout_devtools_core = require("@jfdevelops/react-layout-devtools-core");
+
+//#region src/lazy/inspection.ts
+/** Register a declaration before its import runs, retaining one node on retry. */
+function inspectLazy(label, store = (0, _jfdevelops_react_layout_devtools_core.createInspectionStore)(), parent) {
+	const id = (0, _jfdevelops_react_layout_devtools_core.inspectionId)("lazy");
+	function update(status, error) {
+		store.node({
+			id,
+			kind: "lazy",
+			label,
+			status,
+			unresolved: status !== "resolved",
+			error: error && (0, _jfdevelops_react_layout_devtools_core.serializeInspectionError)(error)
+		});
+	}
+	update("unresolved");
+	if (parent) store.edge(parent, id, "declares");
+	return {
+		id,
+		store,
+		hooks: {
+			onLoadStart: () => update("loading"),
+			onLoadSuccess: () => update("resolved"),
+			onLoadError: (error) => update("error", error),
+			onMount: () => store.mount(id)
+		},
+		setLabel(value) {
+			label = value;
+			update("unresolved");
+		}
+	};
+}
+function withLazyHandle(target, handle) {
+	Object.defineProperties(target, {
+		preload: {
+			value: handle.preload,
+			enumerable: false
+		},
+		status: {
+			get: () => handle.status,
+			enumerable: false
+		}
+	});
+	return target;
+}
+
+//#endregion
+exports.inspectLazy = inspectLazy;
+exports.withLazyHandle = withLazyHandle;
+//# sourceMappingURL=inspection.cjs.map

package/dist/lazy/inspection.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspection.cjs","names":[],"sources":["../../src/lazy/inspection.ts"],"sourcesContent":["import {\n  createInspectionStore,\n  inspectionId,\n  serializeInspectionError,\n  type InspectionStore,\n  type LoadStatus,\n} from '@jfdevelops/react-layout-devtools-core';\nimport type { LazyResourceLoadHooks } from './create-lazy-loader';\nimport type { LazyResourceError } from '../errors/lazy-resource-error';\n\n/** Register a declaration before its import runs, retaining one node on retry. */\nexport function inspectLazy(\n  label: string,\n  store: InspectionStore = createInspectionStore(),\n  parent?: string,\n) {\n  const id = inspectionId('lazy');\n  function update(status: LoadStatus, error?: LazyResourceError) {\n    store.node({\n      id,\n      kind: 'lazy',\n      label,\n      status,\n      unresolved: status !== 'resolved',\n      error: error && serializeInspectionError(error),\n    });\n  }\n  update('unresolved');\n  if (parent) store.edge(parent, id, 'declares');\n  const hooks: LazyResourceLoadHooks = {\n    onLoadStart: () => update('loading'),\n    onLoadSuccess: () => update('resolved'),\n    onLoadError: (error) => update('error', error),\n    onMount: () => store.mount(id),\n  };\n  return {\n    id,\n    store,\n    hooks,\n    setLabel(value: string) {\n      label = value;\n      update('unresolved');\n    },\n  };\n}\n\nexport function withLazyHandle<T extends object>(\n  target: T,\n  handle: import('./types').LazyHandle,\n): T & import('./types').LazyHandle {\n  Object.defineProperties(target, {\n    preload: { value: handle.preload, enumerable: false },\n    status: { get: () => handle.status, enumerable: false },\n  });\n  return target as T & import('./types').LazyHandle;\n}\n"],"mappings":";;;;AAWA,SAAgB,YACd,OACA,0EAA+C,GAC/C,QACA;CACA,MAAM,8DAAkB,MAAM;CAC9B,SAAS,OAAO,QAAoB,OAA2B;EAC7D,MAAM,KAAK;GACT;GACA,MAAM;GACN;GACA;GACA,YAAY,WAAW;GACvB,OAAO,8EAAkC,KAAK;EAChD,CAAC;CACH;CACA,OAAO,YAAY;CACnB,IAAI,QAAQ,MAAM,KAAK,QAAQ,IAAI,UAAU;CAO7C,OAAO;EACL;EACA;EACA;GARA,mBAAmB,OAAO,SAAS;GACnC,qBAAqB,OAAO,UAAU;GACtC,cAAc,UAAU,OAAO,SAAS,KAAK;GAC7C,eAAe,MAAM,MAAM,EAAE;EAKzB;EACJ,SAAS,OAAe;GACtB,QAAQ;GACR,OAAO,YAAY;EACrB;CACF;AACF;AAEA,SAAgB,eACd,QACA,QACkC;CAClC,OAAO,iBAAiB,QAAQ;EAC9B,SAAS;GAAE,OAAO,OAAO;GAAS,YAAY;EAAM;EACpD,QAAQ;GAAE,WAAW,OAAO;GAAQ,YAAY;EAAM;CACxD,CAAC;CACD,OAAO;AACT"}

package/dist/lazy/inspection.d.cts

@@ -0,0 +1,28 @@
+import { LazyResourceLoadHooks } from "./create-lazy-loader.cjs";
+import { InspectionStore } from "@jfdevelops/react-layout-devtools-core";
+
+//#region src/lazy/inspection.d.ts
+/** Register a declaration before its import runs, retaining one node on retry. */
+declare function inspectLazy(label: string, store?: InspectionStore, parent?: string): {
+  id: string;
+  store: {
+    getSnapshot(): import("@jfdevelops/react-layout-devtools-core").GraphSnapshot;
+    subscribe(listener: () => void): () => void;
+    registerPreview(instance: import("@jfdevelops/react-layout-devtools-core").PreviewInstance, controller: import("@jfdevelops/react-layout-devtools-core").PreviewController): () => void;
+    preview(instanceId: string, state?: string): void;
+    previewError(instanceId: string, error: string): void;
+    connectPreview(): () => void;
+    node(node: Omit<import("@jfdevelops/react-layout-devtools-core").GraphNode, "active"> & {
+      active?: number;
+    }): string;
+    edge(source: string, target: string, relationship: import("@jfdevelops/react-layout-devtools-core").GraphEdge["relationship"]): void;
+    mount(...ids: string[]): () => void;
+    connect(value: object): void;
+    attach<T extends object>(value: T): T;
+  };
+  hooks: LazyResourceLoadHooks;
+  setLabel(value: string): void;
+};
+//#endregion
+export { inspectLazy };
+//# sourceMappingURL=inspection.d.cts.map

package/dist/lazy/inspection.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspection.d.cts","names":[],"sources":["../../src/lazy/inspection.ts"],"mappings":";;;;;iBAWgB,WAAA,CACd,KAAA,UACA,KAAA,GAAO,eAAA,EACP,MAAA"}

package/dist/lazy/inspection.d.mts

@@ -0,0 +1,28 @@
+import { LazyResourceLoadHooks } from "./create-lazy-loader.mjs";
+import { InspectionStore } from "@jfdevelops/react-layout-devtools-core";
+
+//#region src/lazy/inspection.d.ts
+/** Register a declaration before its import runs, retaining one node on retry. */
+declare function inspectLazy(label: string, store?: InspectionStore, parent?: string): {
+  id: string;
+  store: {
+    getSnapshot(): import("@jfdevelops/react-layout-devtools-core").GraphSnapshot;
+    subscribe(listener: () => void): () => void;
+    registerPreview(instance: import("@jfdevelops/react-layout-devtools-core").PreviewInstance, controller: import("@jfdevelops/react-layout-devtools-core").PreviewController): () => void;
+    preview(instanceId: string, state?: string): void;
+    previewError(instanceId: string, error: string): void;
+    connectPreview(): () => void;
+    node(node: Omit<import("@jfdevelops/react-layout-devtools-core").GraphNode, "active"> & {
+      active?: number;
+    }): string;
+    edge(source: string, target: string, relationship: import("@jfdevelops/react-layout-devtools-core").GraphEdge["relationship"]): void;
+    mount(...ids: string[]): () => void;
+    connect(value: object): void;
+    attach<T extends object>(value: T): T;
+  };
+  hooks: LazyResourceLoadHooks;
+  setLabel(value: string): void;
+};
+//#endregion
+export { inspectLazy };
+//# sourceMappingURL=inspection.d.mts.map

package/dist/lazy/inspection.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspection.d.mts","names":[],"sources":["../../src/lazy/inspection.ts"],"mappings":";;;;;iBAWgB,WAAA,CACd,KAAA,UACA,KAAA,GAAO,eAAA,EACP,MAAA"}