@jfdevelops/react-layout 1.0.0 → 1.1.0

package/dist/create-config/create-defined-resource-layout.cjs

@@ -44,13 +44,20 @@ function createDefinedResourceLayout(configuration) {
 		lazyDefaults = defaults;
 		lazyDefaultsDefined = true;
 	}
-	const boundDefineResourceLayout = ((layout) => defineBoundLayout({
-		options,
-		layout: {
-			...layout,
-			composables
-		}
-	}));
+	const boundDefineResourceLayout = ((layout) => {
+		const localComposables = layout.composables;
+		return defineBoundLayout({
+			options,
+			namespace: layout.namespace ?? configuration.namespace,
+			layout: {
+				...layout,
+				composables: composables || localComposables ? (create, states) => ({
+					...composables?.(create, states),
+					...localComposables?.(create, states)
+				}) : void 0
+			}
+		});
+	});
 	boundDefineResourceLayout.lazy = (lazyOptions) => {
 		lazyLayoutCreated = true;
 		return require_lazy_resource_layout.createLazyResourceLayout(lazyOptions, lazyDefaults);

package/dist/create-config/create-defined-resource-layout.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-defined-resource-layout.cjs","names":["defineResourceLayout","LayoutConfigurationError","createLazyResourceLayout","createRenderStateBuilder","createLayoutResourcesAccessor"],"sources":["../../src/create-config/create-defined-resource-layout.ts"],"sourcesContent":["import type { ComposableComponents } from '@jfdevelops/react-layout-composables';\nimport { LayoutConfigurationError } from '../errors';\nimport type { InPropsDefinition, InPropsObject } from '../props';\nimport type {\n  IncludedComponentPropDefinitions,\n  MergedLayoutInProps,\n} from '../props';\nimport type { ResourceDefinition } from '../resource';\nimport {\n  type CreateViewMapBuiltInRenderStatesOptions,\n  type CreateViewMapFunctionRenderOptions,\n  type DefinedResourceLayout,\n  defineResourceLayout,\n  type LayoutIncludeProps,\n  type LayoutResourcesAccessor,\n  type TypedBuiltInRenderStates,\n  createLayoutResourcesAccessor,\n} from './define-layout';\nimport {\n  createLazyResourceLayout,\n  type LazyResourceLayoutOptions,\n  type LazyResourceStates,\n} from './lazy-resource-layout';\nimport {\n  createRenderStateBuilder,\n  type CreateRenderState,\n  type LayoutComposablesDefinition,\n} from './render-state';\n\n/** A resource tuple with at least one entry, preserving literal and nested paths. */\nexport type NonEmptyResources = readonly [\n  ResourceDefinition,\n  ...ResourceDefinition[],\n];\n\n/** Configuration shared by every layout created from one defined-layout factory. */\nexport type CreateDefinedResourceLayoutOptions<\n  Resources extends NonEmptyResources,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n> = {\n  /** Resources supported by every layout created from this factory. */\n  resources: Resources;\n  /** Props that render states can opt into through `props.include`. */\n  options?: Options;\n  /** Layout-wide composables available to every render state. */\n  composables?: LayoutComposablesDefinition<Resources, Composables>;\n};\n\n/** The flat layout definition accepted after shared configuration is bound. */\nexport type DefinedResourceLayoutInput<\n  Resources extends NonEmptyResources,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n  IncludeProps extends LayoutIncludeProps<Resources, Options, Composables>,\n  CustomProps extends InPropsObject,\n  Render,\n> = Omit<\n  CreateViewMapFunctionRenderOptions<\n    Resources,\n    Options,\n    Composables,\n    IncludeProps,\n    CustomProps\n  >['layout'],\n  'composables' | 'render'\n> & { render: Render };\n\n/** A `defineResourceLayout` function with its shared configuration pre-bound. */\nexport type BoundDefineResourceLayout<\n  Resources extends NonEmptyResources,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n> = {\n  /** Defines a layout whose `render` value is a single default-state callback. */\n  <\n    const IncludeProps extends LayoutIncludeProps<\n      Resources,\n      Options,\n      Composables\n    > = {},\n    CustomProps extends InPropsObject = {},\n  >(\n    layout: Omit<\n      CreateViewMapFunctionRenderOptions<\n        Resources,\n        Options,\n        Composables,\n        IncludeProps,\n        CustomProps\n      >['layout'],\n      'composables'\n    >,\n  ): DefinedResourceLayout<\n    Resources,\n    Options,\n    Composables,\n    IncludeProps,\n    CustomProps,\n    {}\n  >;\n  /**\n   * Defines a layout whose `render` map contains the required `default` state\n   * and any built-in or custom compound component states.\n   */\n  <\n    const IncludeProps extends LayoutIncludeProps<\n      Resources,\n      Options,\n      Composables\n    > = {},\n    CustomProps extends InPropsObject = {},\n    DefaultComposables extends ComposableComponents = {},\n    const DefaultIncludeProps extends LayoutIncludeProps<\n      Resources,\n      Options,\n      Composables & DefaultComposables\n    > = {},\n    DefaultCustomProps extends InPropsObject = {},\n    LoadingComposables extends ComposableComponents = {},\n    const LoadingIncludeProps extends LayoutIncludeProps<\n      Resources,\n      Options,\n      Composables & LoadingComposables\n    > = {},\n    LoadingCustomProps extends InPropsObject = {},\n    ErrorComposables extends ComposableComponents = {},\n    const ErrorIncludeProps extends LayoutIncludeProps<\n      Resources,\n      Options,\n      Composables & ErrorComposables\n    > = {},\n    ErrorCustomProps extends InPropsObject = {},\n    NotFoundComposables extends ComposableComponents = {},\n    const NotFoundIncludeProps extends LayoutIncludeProps<\n      Resources,\n      Options,\n      Composables & NotFoundComposables\n    > = {},\n    NotFoundCustomProps extends InPropsObject = {},\n    const RenderStates extends { default: unknown } & Record<string, unknown> = {\n      default: unknown;\n    },\n  >(\n    layout: Omit<\n      CreateViewMapBuiltInRenderStatesOptions<\n        Resources,\n        Options,\n        Composables,\n        IncludeProps,\n        CustomProps,\n        TypedBuiltInRenderStates<\n          Resources,\n          Options,\n          Composables,\n          DefaultComposables,\n          DefaultIncludeProps,\n          DefaultCustomProps,\n          LoadingComposables,\n          LoadingIncludeProps,\n          LoadingCustomProps,\n          ErrorComposables,\n          ErrorIncludeProps,\n          ErrorCustomProps,\n          NotFoundComposables,\n          NotFoundIncludeProps,\n          NotFoundCustomProps\n        > & RenderStates\n      >['layout'],\n      'composables'\n    >,\n  ): DefinedResourceLayout<\n    Resources,\n    Options,\n    Composables &\n      DefaultComposables &\n      LoadingComposables &\n      ErrorComposables &\n      NotFoundComposables,\n    DefaultIncludeProps &\n      LoadingIncludeProps &\n      ErrorIncludeProps &\n      NotFoundIncludeProps,\n    DefaultCustomProps &\n      IncludedComponentPropDefinitions<\n        MergedLayoutInProps<\n          Resources,\n          Options,\n          Composables & DefaultComposables\n        >,\n        DefaultIncludeProps\n      >,\n    RenderStates\n  >;\n  /**\n   * Creates a lazy proxy for the single library-defined component exported by\n   * a resource module.\n   *\n   * @param options - Resource path and named-module import callback.\n   */\n  lazy<Module extends Record<string, unknown>>(\n    options: LazyResourceLayoutOptions<Resources, Module>,\n  ): ReturnType<typeof createLazyResourceLayout<Resources, Module>>;\n};\n\n/** Registers loading and module-error components used by lazy layouts. */\nexport type DefineLazyDefaults = {\n  /**\n   * Sets defaults once, before the factory creates its first lazy layout.\n   *\n   * @param defaults - Shared components for pending module loads and failures.\n   */\n  (defaults: LazyResourceStates): void;\n};\n\n/** Reusable helpers produced by {@link createDefinedResourceLayout}. */\nexport type CreateDefinedResourceLayoutResult<\n  Resources extends NonEmptyResources,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n> = {\n  /** Creates eager, deferred, or separately imported render-state fragments. */\n  createRenderState: CreateRenderState<Resources, Options, Composables>;\n  /** Sets the shared loading and module-error UI used by lazy layouts. */\n  defineLazyDefaults: DefineLazyDefaults;\n  /** Defines a layout using the resources, options, and composables already bound. */\n  defineResourceLayout: BoundDefineResourceLayout<\n    Resources,\n    Options,\n    Composables\n  >;\n  /** Reads, selects, or validates the resources bound to this factory. */\n  resources: LayoutResourcesAccessor<Resources>;\n};\n\n/**\n * Creates type-linked layout helpers from one shared configuration. The returned\n * `defineResourceLayout` accepts the layout directly, while `createRenderState`\n * carries the same resource and option types across file boundaries.\n *\n * @param configuration - Resources and optional shared props/composables to\n * bind to every returned helper.\n * @returns Helpers that share the configuration's inferred literal types.\n *\n * @example\n * ```tsx\n * const { createRenderState, defineResourceLayout } =\n *   createDefinedResourceLayout({\n *     resources: ['users'],\n *     options: { title: createProp.string() },\n *   });\n *\n * const Loading = createRenderState({\n *   state: 'Loading',\n *   props: { include: { title: true } },\n *   render: ({ title }) => <p>Loading {title}</p>,\n * });\n *\n * export const usersLayout = defineResourceLayout({\n *   render: { default: () => <Users />, ...Loading },\n * });\n * ```\n */\nexport function createDefinedResourceLayout<\n  const Resources extends NonEmptyResources,\n  const Options extends InPropsDefinition<Resources> = {},\n  Composables extends ComposableComponents = {},\n>(\n  configuration: CreateDefinedResourceLayoutOptions<\n    Resources,\n    Options,\n    Composables\n  >,\n): CreateDefinedResourceLayoutResult<Resources, Options, Composables> {\n  const { resources, options = {} as Options, composables } = configuration;\n  const defineBoundLayout = defineResourceLayout.forResources(...resources);\n  let lazyDefaults: LazyResourceStates = {};\n  let lazyDefaultsDefined = false;\n  let lazyLayoutCreated = false;\n\n  function defineLazyDefaults(defaults: LazyResourceStates): void {\n    if (lazyDefaultsDefined) {\n      throw new LayoutConfigurationError(\n        'Lazy resource defaults can only be defined once.',\n      );\n    }\n\n    if (lazyLayoutCreated) {\n      throw new LayoutConfigurationError(\n        'Lazy resource defaults must be defined before creating a lazy resource layout.',\n      );\n    }\n\n    lazyDefaults = defaults;\n    lazyDefaultsDefined = true;\n  }\n\n  const boundDefineResourceLayout = ((layout: Record<string, unknown>) =>\n    defineBoundLayout({\n      options,\n      layout: { ...layout, composables },\n    } as never)) as unknown as BoundDefineResourceLayout<\n    Resources,\n    Options,\n    Composables\n  >;\n\n  boundDefineResourceLayout.lazy = <Module extends Record<string, unknown>>(\n    lazyOptions: LazyResourceLayoutOptions<Resources, Module>,\n  ): ReturnType<typeof createLazyResourceLayout<Resources, Module>> => {\n    lazyLayoutCreated = true;\n    return createLazyResourceLayout(lazyOptions, lazyDefaults);\n  };\n\n  return {\n    createRenderState: createRenderStateBuilder({\n      composables,\n      options,\n      resources,\n    }),\n    defineLazyDefaults,\n    defineResourceLayout: boundDefineResourceLayout,\n    resources: createLayoutResourcesAccessor(resources),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuQA,SAAgB,4BAKd,eAKoE;CACpE,MAAM,EAAE,WAAW,UAAU,CAAC,GAAc,gBAAgB;CAC5D,MAAM,oBAAoBA,2CAAqB,aAAa,GAAG,SAAS;CACxE,IAAI,eAAmC,CAAC;CACxC,IAAI,sBAAsB;CAC1B,IAAI,oBAAoB;CAExB,SAAS,mBAAmB,UAAoC;EAC9D,IAAI,qBACF,MAAM,IAAIC,4DACR,kDACF;EAGF,IAAI,mBACF,MAAM,IAAIA,4DACR,gFACF;EAGF,eAAe;EACf,sBAAsB;CACxB;CAEA,MAAM,8BAA8B,WAClC,kBAAkB;EAChB;EACA,QAAQ;GAAE,GAAG;GAAQ;EAAY;CACnC,CAAU;CAMZ,0BAA0B,QACxB,gBACmE;EACnE,oBAAoB;EACpB,OAAOC,sDAAyB,aAAa,YAAY;CAC3D;CAEA,OAAO;EACL,mBAAmBC,8CAAyB;GAC1C;GACA;GACA;EACF,CAAC;EACD;EACA,sBAAsB;EACtB,WAAWC,oDAA8B,SAAS;CACpD;AACF"}
+{"version":3,"file":"create-defined-resource-layout.cjs","names":["defineResourceLayout","LayoutConfigurationError","createLazyResourceLayout","createRenderStateBuilder","createLayoutResourcesAccessor"],"sources":["../../src/create-config/create-defined-resource-layout.ts"],"sourcesContent":["import type { ComposableComponents, CreateLayoutComposable } from '@jfdevelops/react-layout-composables';\nimport { LayoutConfigurationError } from '../errors';\nimport type { InPropsDefinition, InPropsObject } from '../props';\nimport type { LayoutResourceKey, ResourceDefinition } from '../resource';\nimport {\n  type CreateViewMapFunctionRenderOptions,\n  type DefinedResourceLayout,\n  defineResourceLayout,\n  type LayoutIncludeProps,\n  type LayoutResourcesAccessor,\n  type CreateViewMapRenderStatesOptions,\n  type DefinedResourceLayoutFromStates,\n  createLayoutResourcesAccessor,\n} from './define-layout';\nimport {\n  createLazyResourceLayout,\n  type LazyResourceLayoutOptions,\n  type LazyResourceStates,\n} from './lazy-resource-layout';\nimport {\n  createRenderStateBuilder,\n  type CreateRenderState,\n  type RenderStateReferences,\n  type LayoutComposablesDefinition,\n} from './render-state';\n\n/** A resource tuple with at least one entry, preserving literal and nested paths. */\nexport type NonEmptyResources = readonly [\n  ResourceDefinition,\n  ...ResourceDefinition[],\n];\n\n/** Configuration shared by every layout created from one defined-layout factory. */\nexport type CreateDefinedResourceLayoutOptions<\n  Resources extends NonEmptyResources,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n  DefaultNamespace extends boolean = false,\n> = {\n  namespace?: DefaultNamespace;\n  /** Resources supported by every layout created from this factory. */\n  resources: Resources;\n  /** Props that render states can opt into through `props.include`. */\n  options?: Options;\n  /** Layout-wide composables available to every render state. */\n  composables?: LayoutComposablesDefinition<Resources, Composables>;\n};\n\n/** The flat layout definition accepted after shared configuration is bound. */\nexport type DefinedResourceLayoutInput<\n  Resources extends NonEmptyResources,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n  IncludeProps extends LayoutIncludeProps<Resources, Options, Composables>,\n  CustomProps extends InPropsObject,\n  Render,\n  Namespace extends boolean = false,\n> = Omit<\n  CreateViewMapFunctionRenderOptions<\n    Resources,\n    Options,\n    Composables,\n    IncludeProps,\n    CustomProps\n  >['layout'],\n  'composables' | 'render'\n> & { render: Render; namespace?: Namespace };\n\ntype BoundLayoutComposables<\n  Shared extends ComposableComponents,\n  Local extends ComposableComponents,\n> = Omit<Shared, keyof Local> & Local;\n\n/** Flattens a definition's layout while preserving its namespace setting. */\ntype BoundLayoutInput<Definition extends { layout: unknown; namespace?: boolean }> =\n  Definition['layout'] & Pick<Definition, 'namespace'>;\n\n/** A `defineResourceLayout` function with its shared configuration pre-bound. */\nexport type BoundDefineResourceLayout<\n  Resources extends NonEmptyResources,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n  DefaultNamespace extends boolean = false,\n> = {\n  /**\n   * Defines a layout whose `render` map contains the required `default` state\n   * and any built-in or custom compound component states.\n   * Keep this overload first so incomplete render objects suggest state keys.\n   * Use `createRenderState` for state-local `composables(create)` callbacks;\n   * the helper infers their render context independently of the enclosing map.\n   */\n  <\n    const Render extends { default: unknown } & Record<string, unknown>,\n    LocalComposables extends ComposableComponents = {},\n    Namespace extends boolean = DefaultNamespace,\n  >(\n    layout: Omit<\n      BoundLayoutInput<CreateViewMapRenderStatesOptions<Resources, Options, BoundLayoutComposables<Composables, LocalComposables>, {}, {}, Render, Namespace>>,\n      'composables'\n    > & {\n      composables?: (\n        create: CreateLayoutComposable<LayoutResourceKey<Resources>>,\n        states: RenderStateReferences<Resources, Options, Composables, Render>,\n      ) => LocalComposables;\n    },\n  ): DefinedResourceLayoutFromStates<Resources, Options, BoundLayoutComposables<Composables, LocalComposables>, Render, Namespace>;\n  /** Defines a layout whose `render` value is a single default-state callback. */\n  <\n    const IncludeProps extends LayoutIncludeProps<\n      Resources,\n      Options,\n      BoundLayoutComposables<Composables, LocalComposables>\n    > = {},\n    CustomProps extends InPropsObject = {},\n    LocalComposables extends ComposableComponents = {},\n    Namespace extends boolean = DefaultNamespace,\n  >(\n    layout: Omit<\n      BoundLayoutInput<CreateViewMapFunctionRenderOptions<\n        Resources,\n        Options,\n        BoundLayoutComposables<Composables, LocalComposables>,\n        IncludeProps,\n        CustomProps,\n        Namespace\n      >>,\n      'composables'\n    > & {\n      composables?: (\n        create: CreateLayoutComposable<LayoutResourceKey<Resources>>,\n        states: {},\n      ) => LocalComposables;\n    },\n  ): DefinedResourceLayout<\n    Resources,\n    Options,\n    BoundLayoutComposables<Composables, LocalComposables>,\n    IncludeProps,\n    CustomProps,\n    {},\n    Namespace\n  >;\n  /**\n   * Creates a lazy proxy for the single library-defined component exported by\n   * a resource module.\n   *\n   * @param options - Resource path and named-module import callback.\n   */\n  lazy<Module extends Record<string, unknown>>(\n    options: LazyResourceLayoutOptions<Resources, Module>,\n  ): ReturnType<typeof createLazyResourceLayout<Resources, Module>>;\n};\n\n/** Registers loading and module-error components used by lazy layouts. */\nexport type DefineLazyDefaults = {\n  /**\n   * Sets defaults once, before the factory creates its first lazy layout.\n   *\n   * @param defaults - Shared components for pending module loads and failures.\n   */\n  (defaults: LazyResourceStates): void;\n};\n\n/** Reusable helpers produced by {@link createDefinedResourceLayout}. */\nexport type CreateDefinedResourceLayoutResult<\n  Resources extends NonEmptyResources,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n  DefaultNamespace extends boolean = false,\n> = {\n  /** Creates eager, deferred, or separately imported render-state fragments. */\n  createRenderState: CreateRenderState<Resources, Options, Composables>;\n  /** Sets the shared loading and module-error UI used by lazy layouts. */\n  defineLazyDefaults: DefineLazyDefaults;\n  /** Defines a layout using the resources, options, and composables already bound. */\n  defineResourceLayout: BoundDefineResourceLayout<\n    Resources,\n    Options,\n    Composables,\n    DefaultNamespace\n  >;\n  /** Reads, selects, or validates the resources bound to this factory. */\n  resources: LayoutResourcesAccessor<Resources>;\n};\n\n/**\n * Creates type-linked layout helpers from one shared configuration. The returned\n * `defineResourceLayout` accepts the layout directly, while `createRenderState`\n * carries the same resource and option types across file boundaries.\n *\n * @param configuration - Resources and optional shared props/composables to\n * bind to every returned helper.\n * @returns Helpers that share the configuration's inferred literal types.\n *\n * @example\n * ```tsx\n * const { createRenderState, defineResourceLayout } =\n *   createDefinedResourceLayout({\n *     resources: ['users'],\n *     options: { title: createProp.string() },\n *   });\n *\n * const Loading = createRenderState({\n *   state: 'Loading',\n *   props: { include: { title: true } },\n *   render: ({ title }) => <p>Loading {title}</p>,\n * });\n *\n * export const usersLayout = defineResourceLayout({\n *   render: { default: () => <Users />, ...Loading },\n * });\n * ```\n */\nexport function createDefinedResourceLayout<\n  const Resources extends NonEmptyResources,\n  const Options extends InPropsDefinition<Resources> = {},\n  Composables extends ComposableComponents = {},\n  DefaultNamespace extends boolean = false,\n>(\n  configuration: CreateDefinedResourceLayoutOptions<\n    Resources,\n    Options,\n    Composables,\n    DefaultNamespace\n  >,\n): CreateDefinedResourceLayoutResult<Resources, Options, Composables, DefaultNamespace> {\n  const { resources, options = {} as Options, composables } = configuration;\n  const defineBoundLayout = defineResourceLayout.forResources(...resources);\n  let lazyDefaults: LazyResourceStates = {};\n  let lazyDefaultsDefined = false;\n  let lazyLayoutCreated = false;\n\n  function defineLazyDefaults(defaults: LazyResourceStates): void {\n    if (lazyDefaultsDefined) {\n      throw new LayoutConfigurationError(\n        'Lazy resource defaults can only be defined once.',\n      );\n    }\n\n    if (lazyLayoutCreated) {\n      throw new LayoutConfigurationError(\n        'Lazy resource defaults must be defined before creating a lazy resource layout.',\n      );\n    }\n\n    lazyDefaults = defaults;\n    lazyDefaultsDefined = true;\n  }\n\n  const boundDefineResourceLayout = ((layout: Record<string, unknown>) => {\n    const localComposables = layout.composables as LayoutComposablesDefinition<Resources, ComposableComponents> | undefined;\n    return defineBoundLayout({\n      options,\n      namespace: layout.namespace ?? configuration.namespace,\n      layout: {\n        ...layout,\n        composables: composables || localComposables\n          ? (create: CreateLayoutComposable<LayoutResourceKey<Resources>>, states: {}) => ({\n              ...composables?.(create, states),\n              ...localComposables?.(create, states),\n            })\n          : undefined,\n      },\n    } as never);\n  }) as unknown as BoundDefineResourceLayout<\n    Resources,\n    Options,\n    Composables,\n    DefaultNamespace\n  >;\n\n  boundDefineResourceLayout.lazy = <Module extends Record<string, unknown>>(\n    lazyOptions: LazyResourceLayoutOptions<Resources, Module>,\n  ): ReturnType<typeof createLazyResourceLayout<Resources, Module>> => {\n    lazyLayoutCreated = true;\n    return createLazyResourceLayout(lazyOptions, lazyDefaults);\n  };\n\n  return {\n    createRenderState: createRenderStateBuilder({\n      composables,\n      options,\n      resources,\n    }),\n    defineLazyDefaults,\n    defineResourceLayout: boundDefineResourceLayout,\n    resources: createLayoutResourcesAccessor(resources),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqNA,SAAgB,4BAMd,eAMsF;CACtF,MAAM,EAAE,WAAW,UAAU,CAAC,GAAc,gBAAgB;CAC5D,MAAM,oBAAoBA,2CAAqB,aAAa,GAAG,SAAS;CACxE,IAAI,eAAmC,CAAC;CACxC,IAAI,sBAAsB;CAC1B,IAAI,oBAAoB;CAExB,SAAS,mBAAmB,UAAoC;EAC9D,IAAI,qBACF,MAAM,IAAIC,4DACR,kDACF;EAGF,IAAI,mBACF,MAAM,IAAIA,4DACR,gFACF;EAGF,eAAe;EACf,sBAAsB;CACxB;CAEA,MAAM,8BAA8B,WAAoC;EACtE,MAAM,mBAAmB,OAAO;EAChC,OAAO,kBAAkB;GACvB;GACA,WAAW,OAAO,aAAa,cAAc;GAC7C,QAAQ;IACN,GAAG;IACH,aAAa,eAAe,oBACvB,QAA8D,YAAgB;KAC7E,GAAG,cAAc,QAAQ,MAAM;KAC/B,GAAG,mBAAmB,QAAQ,MAAM;IACtC,KACA;GACN;EACF,CAAU;CACZ;CAOA,0BAA0B,QACxB,gBACmE;EACnE,oBAAoB;EACpB,OAAOC,sDAAyB,aAAa,YAAY;CAC3D;CAEA,OAAO;EACL,mBAAmBC,8CAAyB;GAC1C;GACA;GACA;EACF,CAAC;EACD;EACA,sBAAsB;EACtB,WAAWC,oDAA8B,SAAS;CACpD;AACF"}

package/dist/create-config/create-defined-resource-layout.d.cts

@@ -1,35 +1,48 @@
-import { ResourceDefinition } from "../resource.cjs";
-import { InPropsDefinition, InPropsObject, IncludedComponentPropDefinitions, MergedLayoutInProps } from "../props.cjs";
-import { CreateRenderState, LayoutComposablesDefinition } from "./render-state.cjs";
-import { CreateViewMapBuiltInRenderStatesOptions, CreateViewMapFunctionRenderOptions, DefinedResourceLayout, LayoutIncludeProps, LayoutResourcesAccessor, TypedBuiltInRenderStates } from "./define-layout.cjs";
+import { LayoutResourceKey, ResourceDefinition } from "../resource.cjs";
+import { InPropsDefinition, InPropsObject } from "../props.cjs";
+import { CreateRenderState, LayoutComposablesDefinition, RenderStateReferences } from "./render-state.cjs";
+import { CreateViewMapFunctionRenderOptions, CreateViewMapRenderStatesOptions, DefinedResourceLayout, DefinedResourceLayoutFromStates, LayoutIncludeProps, LayoutResourcesAccessor } from "./define-layout.cjs";
 import { LazyResourceLayoutOptions, LazyResourceStates, createLazyResourceLayout } from "./lazy-resource-layout.cjs";
-import { ComposableComponents } from "@jfdevelops/react-layout-composables";
+import { ComposableComponents, CreateLayoutComposable } from "@jfdevelops/react-layout-composables";
 
 //#region src/create-config/create-defined-resource-layout.d.ts
 /** A resource tuple with at least one entry, preserving literal and nested paths. */
 type NonEmptyResources = readonly [ResourceDefinition, ...ResourceDefinition[]];
 /** Configuration shared by every layout created from one defined-layout factory. */
-type CreateDefinedResourceLayoutOptions<Resources extends NonEmptyResources, Options extends InPropsDefinition<Resources>, Composables extends ComposableComponents> = {
-  /** Resources supported by every layout created from this factory. */resources: Resources; /** Props that render states can opt into through `props.include`. */
+type CreateDefinedResourceLayoutOptions<Resources extends NonEmptyResources, Options extends InPropsDefinition<Resources>, Composables extends ComposableComponents, DefaultNamespace extends boolean = false> = {
+  namespace?: DefaultNamespace; /** Resources supported by every layout created from this factory. */
+  resources: Resources; /** Props that render states can opt into through `props.include`. */
   options?: Options; /** Layout-wide composables available to every render state. */
   composables?: LayoutComposablesDefinition<Resources, Composables>;
 };
 /** The flat layout definition accepted after shared configuration is bound. */
-type DefinedResourceLayoutInput<Resources extends NonEmptyResources, Options extends InPropsDefinition<Resources>, Composables extends ComposableComponents, IncludeProps extends LayoutIncludeProps<Resources, Options, Composables>, CustomProps extends InPropsObject, Render> = Omit<CreateViewMapFunctionRenderOptions<Resources, Options, Composables, IncludeProps, CustomProps>['layout'], 'composables' | 'render'> & {
+type DefinedResourceLayoutInput<Resources extends NonEmptyResources, Options extends InPropsDefinition<Resources>, Composables extends ComposableComponents, IncludeProps extends LayoutIncludeProps<Resources, Options, Composables>, CustomProps extends InPropsObject, Render, Namespace extends boolean = false> = Omit<CreateViewMapFunctionRenderOptions<Resources, Options, Composables, IncludeProps, CustomProps>['layout'], 'composables' | 'render'> & {
   render: Render;
+  namespace?: Namespace;
 };
+type BoundLayoutComposables<Shared extends ComposableComponents, Local extends ComposableComponents> = Omit<Shared, keyof Local> & Local;
+/** Flattens a definition's layout while preserving its namespace setting. */
+type BoundLayoutInput<Definition extends {
+  layout: unknown;
+  namespace?: boolean;
+}> = Definition['layout'] & Pick<Definition, 'namespace'>;
 /** A `defineResourceLayout` function with its shared configuration pre-bound. */
-type BoundDefineResourceLayout<Resources extends NonEmptyResources, Options extends InPropsDefinition<Resources>, Composables extends ComposableComponents> = {
-  /** Defines a layout whose `render` value is a single default-state callback. */<const IncludeProps extends LayoutIncludeProps<Resources, Options, Composables> = {}, CustomProps extends InPropsObject = {}>(layout: Omit<CreateViewMapFunctionRenderOptions<Resources, Options, Composables, IncludeProps, CustomProps>['layout'], 'composables'>): DefinedResourceLayout<Resources, Options, Composables, IncludeProps, CustomProps, {}>;
+type BoundDefineResourceLayout<Resources extends NonEmptyResources, Options extends InPropsDefinition<Resources>, Composables extends ComposableComponents, DefaultNamespace extends boolean = false> = {
   /**
    * Defines a layout whose `render` map contains the required `default` state
    * and any built-in or custom compound component states.
+   * Keep this overload first so incomplete render objects suggest state keys.
+   * Use `createRenderState` for state-local `composables(create)` callbacks;
+   * the helper infers their render context independently of the enclosing map.
    */
-  <const IncludeProps extends LayoutIncludeProps<Resources, Options, Composables> = {}, CustomProps extends InPropsObject = {}, DefaultComposables extends ComposableComponents = {}, const DefaultIncludeProps extends LayoutIncludeProps<Resources, Options, Composables & DefaultComposables> = {}, DefaultCustomProps extends InPropsObject = {}, LoadingComposables extends ComposableComponents = {}, const LoadingIncludeProps extends LayoutIncludeProps<Resources, Options, Composables & LoadingComposables> = {}, LoadingCustomProps extends InPropsObject = {}, ErrorComposables extends ComposableComponents = {}, const ErrorIncludeProps extends LayoutIncludeProps<Resources, Options, Composables & ErrorComposables> = {}, ErrorCustomProps extends InPropsObject = {}, NotFoundComposables extends ComposableComponents = {}, const NotFoundIncludeProps extends LayoutIncludeProps<Resources, Options, Composables & NotFoundComposables> = {}, NotFoundCustomProps extends InPropsObject = {}, const RenderStates extends {
+  <const Render extends {
     default: unknown;
-  } & Record<string, unknown> = {
-    default: unknown;
-  }>(layout: Omit<CreateViewMapBuiltInRenderStatesOptions<Resources, Options, Composables, IncludeProps, CustomProps, TypedBuiltInRenderStates<Resources, Options, Composables, DefaultComposables, DefaultIncludeProps, DefaultCustomProps, LoadingComposables, LoadingIncludeProps, LoadingCustomProps, ErrorComposables, ErrorIncludeProps, ErrorCustomProps, NotFoundComposables, NotFoundIncludeProps, NotFoundCustomProps> & RenderStates>['layout'], 'composables'>): DefinedResourceLayout<Resources, Options, Composables & DefaultComposables & LoadingComposables & ErrorComposables & NotFoundComposables, DefaultIncludeProps & LoadingIncludeProps & ErrorIncludeProps & NotFoundIncludeProps, DefaultCustomProps & IncludedComponentPropDefinitions<MergedLayoutInProps<Resources, Options, Composables & DefaultComposables>, DefaultIncludeProps>, RenderStates>;
+  } & Record<string, unknown>, LocalComposables extends ComposableComponents = {}, Namespace extends boolean = DefaultNamespace>(layout: Omit<BoundLayoutInput<CreateViewMapRenderStatesOptions<Resources, Options, BoundLayoutComposables<Composables, LocalComposables>, {}, {}, Render, Namespace>>, 'composables'> & {
+    composables?: (create: CreateLayoutComposable<LayoutResourceKey<Resources>>, states: RenderStateReferences<Resources, Options, Composables, Render>) => LocalComposables;
+  }): DefinedResourceLayoutFromStates<Resources, Options, BoundLayoutComposables<Composables, LocalComposables>, Render, Namespace>; /** Defines a layout whose `render` value is a single default-state callback. */
+  <const IncludeProps extends LayoutIncludeProps<Resources, Options, BoundLayoutComposables<Composables, LocalComposables>> = {}, CustomProps extends InPropsObject = {}, LocalComposables extends ComposableComponents = {}, Namespace extends boolean = DefaultNamespace>(layout: Omit<BoundLayoutInput<CreateViewMapFunctionRenderOptions<Resources, Options, BoundLayoutComposables<Composables, LocalComposables>, IncludeProps, CustomProps, Namespace>>, 'composables'> & {
+    composables?: (create: CreateLayoutComposable<LayoutResourceKey<Resources>>, states: {}) => LocalComposables;
+  }): DefinedResourceLayout<Resources, Options, BoundLayoutComposables<Composables, LocalComposables>, IncludeProps, CustomProps, {}, Namespace>;
   /**
    * Creates a lazy proxy for the single library-defined component exported by
    * a resource module.
@@ -48,10 +61,10 @@ type DefineLazyDefaults = {
   (defaults: LazyResourceStates): void;
 };
 /** Reusable helpers produced by {@link createDefinedResourceLayout}. */
-type CreateDefinedResourceLayoutResult<Resources extends NonEmptyResources, Options extends InPropsDefinition<Resources>, Composables extends ComposableComponents> = {
+type CreateDefinedResourceLayoutResult<Resources extends NonEmptyResources, Options extends InPropsDefinition<Resources>, Composables extends ComposableComponents, DefaultNamespace extends boolean = false> = {
   /** Creates eager, deferred, or separately imported render-state fragments. */createRenderState: CreateRenderState<Resources, Options, Composables>; /** Sets the shared loading and module-error UI used by lazy layouts. */
   defineLazyDefaults: DefineLazyDefaults; /** Defines a layout using the resources, options, and composables already bound. */
-  defineResourceLayout: BoundDefineResourceLayout<Resources, Options, Composables>; /** Reads, selects, or validates the resources bound to this factory. */
+  defineResourceLayout: BoundDefineResourceLayout<Resources, Options, Composables, DefaultNamespace>; /** Reads, selects, or validates the resources bound to this factory. */
   resources: LayoutResourcesAccessor<Resources>;
 };
 /**
@@ -82,7 +95,7 @@ type CreateDefinedResourceLayoutResult<Resources extends NonEmptyResources, Opti
  * });
  * ```
  */
-declare function createDefinedResourceLayout<const Resources extends NonEmptyResources, const Options extends InPropsDefinition<Resources> = {}, Composables extends ComposableComponents = {}>(configuration: CreateDefinedResourceLayoutOptions<Resources, Options, Composables>): CreateDefinedResourceLayoutResult<Resources, Options, Composables>;
+declare function createDefinedResourceLayout<const Resources extends NonEmptyResources, const Options extends InPropsDefinition<Resources> = {}, Composables extends ComposableComponents = {}, DefaultNamespace extends boolean = false>(configuration: CreateDefinedResourceLayoutOptions<Resources, Options, Composables, DefaultNamespace>): CreateDefinedResourceLayoutResult<Resources, Options, Composables, DefaultNamespace>;
 //#endregion
 export { BoundDefineResourceLayout, CreateDefinedResourceLayoutOptions, CreateDefinedResourceLayoutResult, DefineLazyDefaults, DefinedResourceLayoutInput, NonEmptyResources, createDefinedResourceLayout };
 //# sourceMappingURL=create-defined-resource-layout.d.cts.map

package/dist/create-config/create-defined-resource-layout.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"create-defined-resource-layout.d.cts","names":[],"sources":["../../src/create-config/create-defined-resource-layout.ts"],"mappings":"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"}
+{"version":3,"file":"create-defined-resource-layout.d.cts","names":[],"sources":["../../src/create-config/create-defined-resource-layout.ts"],"mappings":"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"}

package/dist/create-config/create-defined-resource-layout.d.mts

@@ -1,35 +1,48 @@
-import { ResourceDefinition } from "../resource.mjs";
-import { InPropsDefinition, InPropsObject, IncludedComponentPropDefinitions, MergedLayoutInProps } from "../props.mjs";
-import { CreateRenderState, LayoutComposablesDefinition } from "./render-state.mjs";
-import { CreateViewMapBuiltInRenderStatesOptions, CreateViewMapFunctionRenderOptions, DefinedResourceLayout, LayoutIncludeProps, LayoutResourcesAccessor, TypedBuiltInRenderStates } from "./define-layout.mjs";
+import { LayoutResourceKey, ResourceDefinition } from "../resource.mjs";
+import { InPropsDefinition, InPropsObject } from "../props.mjs";
+import { CreateRenderState, LayoutComposablesDefinition, RenderStateReferences } from "./render-state.mjs";
+import { CreateViewMapFunctionRenderOptions, CreateViewMapRenderStatesOptions, DefinedResourceLayout, DefinedResourceLayoutFromStates, LayoutIncludeProps, LayoutResourcesAccessor } from "./define-layout.mjs";
 import { LazyResourceLayoutOptions, LazyResourceStates, createLazyResourceLayout } from "./lazy-resource-layout.mjs";
-import { ComposableComponents } from "@jfdevelops/react-layout-composables";
+import { ComposableComponents, CreateLayoutComposable } from "@jfdevelops/react-layout-composables";
 
 //#region src/create-config/create-defined-resource-layout.d.ts
 /** A resource tuple with at least one entry, preserving literal and nested paths. */
 type NonEmptyResources = readonly [ResourceDefinition, ...ResourceDefinition[]];
 /** Configuration shared by every layout created from one defined-layout factory. */
-type CreateDefinedResourceLayoutOptions<Resources extends NonEmptyResources, Options extends InPropsDefinition<Resources>, Composables extends ComposableComponents> = {
-  /** Resources supported by every layout created from this factory. */resources: Resources; /** Props that render states can opt into through `props.include`. */
+type CreateDefinedResourceLayoutOptions<Resources extends NonEmptyResources, Options extends InPropsDefinition<Resources>, Composables extends ComposableComponents, DefaultNamespace extends boolean = false> = {
+  namespace?: DefaultNamespace; /** Resources supported by every layout created from this factory. */
+  resources: Resources; /** Props that render states can opt into through `props.include`. */
   options?: Options; /** Layout-wide composables available to every render state. */
   composables?: LayoutComposablesDefinition<Resources, Composables>;
 };
 /** The flat layout definition accepted after shared configuration is bound. */
-type DefinedResourceLayoutInput<Resources extends NonEmptyResources, Options extends InPropsDefinition<Resources>, Composables extends ComposableComponents, IncludeProps extends LayoutIncludeProps<Resources, Options, Composables>, CustomProps extends InPropsObject, Render> = Omit<CreateViewMapFunctionRenderOptions<Resources, Options, Composables, IncludeProps, CustomProps>['layout'], 'composables' | 'render'> & {
+type DefinedResourceLayoutInput<Resources extends NonEmptyResources, Options extends InPropsDefinition<Resources>, Composables extends ComposableComponents, IncludeProps extends LayoutIncludeProps<Resources, Options, Composables>, CustomProps extends InPropsObject, Render, Namespace extends boolean = false> = Omit<CreateViewMapFunctionRenderOptions<Resources, Options, Composables, IncludeProps, CustomProps>['layout'], 'composables' | 'render'> & {
   render: Render;
+  namespace?: Namespace;
 };
+type BoundLayoutComposables<Shared extends ComposableComponents, Local extends ComposableComponents> = Omit<Shared, keyof Local> & Local;
+/** Flattens a definition's layout while preserving its namespace setting. */
+type BoundLayoutInput<Definition extends {
+  layout: unknown;
+  namespace?: boolean;
+}> = Definition['layout'] & Pick<Definition, 'namespace'>;
 /** A `defineResourceLayout` function with its shared configuration pre-bound. */
-type BoundDefineResourceLayout<Resources extends NonEmptyResources, Options extends InPropsDefinition<Resources>, Composables extends ComposableComponents> = {
-  /** Defines a layout whose `render` value is a single default-state callback. */<const IncludeProps extends LayoutIncludeProps<Resources, Options, Composables> = {}, CustomProps extends InPropsObject = {}>(layout: Omit<CreateViewMapFunctionRenderOptions<Resources, Options, Composables, IncludeProps, CustomProps>['layout'], 'composables'>): DefinedResourceLayout<Resources, Options, Composables, IncludeProps, CustomProps, {}>;
+type BoundDefineResourceLayout<Resources extends NonEmptyResources, Options extends InPropsDefinition<Resources>, Composables extends ComposableComponents, DefaultNamespace extends boolean = false> = {
   /**
    * Defines a layout whose `render` map contains the required `default` state
    * and any built-in or custom compound component states.
+   * Keep this overload first so incomplete render objects suggest state keys.
+   * Use `createRenderState` for state-local `composables(create)` callbacks;
+   * the helper infers their render context independently of the enclosing map.
    */
-  <const IncludeProps extends LayoutIncludeProps<Resources, Options, Composables> = {}, CustomProps extends InPropsObject = {}, DefaultComposables extends ComposableComponents = {}, const DefaultIncludeProps extends LayoutIncludeProps<Resources, Options, Composables & DefaultComposables> = {}, DefaultCustomProps extends InPropsObject = {}, LoadingComposables extends ComposableComponents = {}, const LoadingIncludeProps extends LayoutIncludeProps<Resources, Options, Composables & LoadingComposables> = {}, LoadingCustomProps extends InPropsObject = {}, ErrorComposables extends ComposableComponents = {}, const ErrorIncludeProps extends LayoutIncludeProps<Resources, Options, Composables & ErrorComposables> = {}, ErrorCustomProps extends InPropsObject = {}, NotFoundComposables extends ComposableComponents = {}, const NotFoundIncludeProps extends LayoutIncludeProps<Resources, Options, Composables & NotFoundComposables> = {}, NotFoundCustomProps extends InPropsObject = {}, const RenderStates extends {
+  <const Render extends {
     default: unknown;
-  } & Record<string, unknown> = {
-    default: unknown;
-  }>(layout: Omit<CreateViewMapBuiltInRenderStatesOptions<Resources, Options, Composables, IncludeProps, CustomProps, TypedBuiltInRenderStates<Resources, Options, Composables, DefaultComposables, DefaultIncludeProps, DefaultCustomProps, LoadingComposables, LoadingIncludeProps, LoadingCustomProps, ErrorComposables, ErrorIncludeProps, ErrorCustomProps, NotFoundComposables, NotFoundIncludeProps, NotFoundCustomProps> & RenderStates>['layout'], 'composables'>): DefinedResourceLayout<Resources, Options, Composables & DefaultComposables & LoadingComposables & ErrorComposables & NotFoundComposables, DefaultIncludeProps & LoadingIncludeProps & ErrorIncludeProps & NotFoundIncludeProps, DefaultCustomProps & IncludedComponentPropDefinitions<MergedLayoutInProps<Resources, Options, Composables & DefaultComposables>, DefaultIncludeProps>, RenderStates>;
+  } & Record<string, unknown>, LocalComposables extends ComposableComponents = {}, Namespace extends boolean = DefaultNamespace>(layout: Omit<BoundLayoutInput<CreateViewMapRenderStatesOptions<Resources, Options, BoundLayoutComposables<Composables, LocalComposables>, {}, {}, Render, Namespace>>, 'composables'> & {
+    composables?: (create: CreateLayoutComposable<LayoutResourceKey<Resources>>, states: RenderStateReferences<Resources, Options, Composables, Render>) => LocalComposables;
+  }): DefinedResourceLayoutFromStates<Resources, Options, BoundLayoutComposables<Composables, LocalComposables>, Render, Namespace>; /** Defines a layout whose `render` value is a single default-state callback. */
+  <const IncludeProps extends LayoutIncludeProps<Resources, Options, BoundLayoutComposables<Composables, LocalComposables>> = {}, CustomProps extends InPropsObject = {}, LocalComposables extends ComposableComponents = {}, Namespace extends boolean = DefaultNamespace>(layout: Omit<BoundLayoutInput<CreateViewMapFunctionRenderOptions<Resources, Options, BoundLayoutComposables<Composables, LocalComposables>, IncludeProps, CustomProps, Namespace>>, 'composables'> & {
+    composables?: (create: CreateLayoutComposable<LayoutResourceKey<Resources>>, states: {}) => LocalComposables;
+  }): DefinedResourceLayout<Resources, Options, BoundLayoutComposables<Composables, LocalComposables>, IncludeProps, CustomProps, {}, Namespace>;
   /**
    * Creates a lazy proxy for the single library-defined component exported by
    * a resource module.
@@ -48,10 +61,10 @@ type DefineLazyDefaults = {
   (defaults: LazyResourceStates): void;
 };
 /** Reusable helpers produced by {@link createDefinedResourceLayout}. */
-type CreateDefinedResourceLayoutResult<Resources extends NonEmptyResources, Options extends InPropsDefinition<Resources>, Composables extends ComposableComponents> = {
+type CreateDefinedResourceLayoutResult<Resources extends NonEmptyResources, Options extends InPropsDefinition<Resources>, Composables extends ComposableComponents, DefaultNamespace extends boolean = false> = {
   /** Creates eager, deferred, or separately imported render-state fragments. */createRenderState: CreateRenderState<Resources, Options, Composables>; /** Sets the shared loading and module-error UI used by lazy layouts. */
   defineLazyDefaults: DefineLazyDefaults; /** Defines a layout using the resources, options, and composables already bound. */
-  defineResourceLayout: BoundDefineResourceLayout<Resources, Options, Composables>; /** Reads, selects, or validates the resources bound to this factory. */
+  defineResourceLayout: BoundDefineResourceLayout<Resources, Options, Composables, DefaultNamespace>; /** Reads, selects, or validates the resources bound to this factory. */
   resources: LayoutResourcesAccessor<Resources>;
 };
 /**
@@ -82,7 +95,7 @@ type CreateDefinedResourceLayoutResult<Resources extends NonEmptyResources, Opti
  * });
  * ```
  */
-declare function createDefinedResourceLayout<const Resources extends NonEmptyResources, const Options extends InPropsDefinition<Resources> = {}, Composables extends ComposableComponents = {}>(configuration: CreateDefinedResourceLayoutOptions<Resources, Options, Composables>): CreateDefinedResourceLayoutResult<Resources, Options, Composables>;
+declare function createDefinedResourceLayout<const Resources extends NonEmptyResources, const Options extends InPropsDefinition<Resources> = {}, Composables extends ComposableComponents = {}, DefaultNamespace extends boolean = false>(configuration: CreateDefinedResourceLayoutOptions<Resources, Options, Composables, DefaultNamespace>): CreateDefinedResourceLayoutResult<Resources, Options, Composables, DefaultNamespace>;
 //#endregion
 export { BoundDefineResourceLayout, CreateDefinedResourceLayoutOptions, CreateDefinedResourceLayoutResult, DefineLazyDefaults, DefinedResourceLayoutInput, NonEmptyResources, createDefinedResourceLayout };
 //# sourceMappingURL=create-defined-resource-layout.d.mts.map

package/dist/create-config/create-defined-resource-layout.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"create-defined-resource-layout.d.mts","names":[],"sources":["../../src/create-config/create-defined-resource-layout.ts"],"mappings":"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"}
+{"version":3,"file":"create-defined-resource-layout.d.mts","names":[],"sources":["../../src/create-config/create-defined-resource-layout.ts"],"mappings":"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"}

package/dist/create-config/create-defined-resource-layout.mjs

@@ -44,13 +44,20 @@ function createDefinedResourceLayout(configuration) {
 		lazyDefaults = defaults;
 		lazyDefaultsDefined = true;
 	}
-	const boundDefineResourceLayout = ((layout) => defineBoundLayout({
-		options,
-		layout: {
-			...layout,
-			composables
-		}
-	}));
+	const boundDefineResourceLayout = ((layout) => {
+		const localComposables = layout.composables;
+		return defineBoundLayout({
+			options,
+			namespace: layout.namespace ?? configuration.namespace,
+			layout: {
+				...layout,
+				composables: composables || localComposables ? (create, states) => ({
+					...composables?.(create, states),
+					...localComposables?.(create, states)
+				}) : void 0
+			}
+		});
+	});
 	boundDefineResourceLayout.lazy = (lazyOptions) => {
 		lazyLayoutCreated = true;
 		return createLazyResourceLayout(lazyOptions, lazyDefaults);

package/dist/create-config/create-defined-resource-layout.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-defined-resource-layout.mjs","names":[],"sources":["../../src/create-config/create-defined-resource-layout.ts"],"sourcesContent":["import type { ComposableComponents } from '@jfdevelops/react-layout-composables';\nimport { LayoutConfigurationError } from '../errors';\nimport type { InPropsDefinition, InPropsObject } from '../props';\nimport type {\n  IncludedComponentPropDefinitions,\n  MergedLayoutInProps,\n} from '../props';\nimport type { ResourceDefinition } from '../resource';\nimport {\n  type CreateViewMapBuiltInRenderStatesOptions,\n  type CreateViewMapFunctionRenderOptions,\n  type DefinedResourceLayout,\n  defineResourceLayout,\n  type LayoutIncludeProps,\n  type LayoutResourcesAccessor,\n  type TypedBuiltInRenderStates,\n  createLayoutResourcesAccessor,\n} from './define-layout';\nimport {\n  createLazyResourceLayout,\n  type LazyResourceLayoutOptions,\n  type LazyResourceStates,\n} from './lazy-resource-layout';\nimport {\n  createRenderStateBuilder,\n  type CreateRenderState,\n  type LayoutComposablesDefinition,\n} from './render-state';\n\n/** A resource tuple with at least one entry, preserving literal and nested paths. */\nexport type NonEmptyResources = readonly [\n  ResourceDefinition,\n  ...ResourceDefinition[],\n];\n\n/** Configuration shared by every layout created from one defined-layout factory. */\nexport type CreateDefinedResourceLayoutOptions<\n  Resources extends NonEmptyResources,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n> = {\n  /** Resources supported by every layout created from this factory. */\n  resources: Resources;\n  /** Props that render states can opt into through `props.include`. */\n  options?: Options;\n  /** Layout-wide composables available to every render state. */\n  composables?: LayoutComposablesDefinition<Resources, Composables>;\n};\n\n/** The flat layout definition accepted after shared configuration is bound. */\nexport type DefinedResourceLayoutInput<\n  Resources extends NonEmptyResources,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n  IncludeProps extends LayoutIncludeProps<Resources, Options, Composables>,\n  CustomProps extends InPropsObject,\n  Render,\n> = Omit<\n  CreateViewMapFunctionRenderOptions<\n    Resources,\n    Options,\n    Composables,\n    IncludeProps,\n    CustomProps\n  >['layout'],\n  'composables' | 'render'\n> & { render: Render };\n\n/** A `defineResourceLayout` function with its shared configuration pre-bound. */\nexport type BoundDefineResourceLayout<\n  Resources extends NonEmptyResources,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n> = {\n  /** Defines a layout whose `render` value is a single default-state callback. */\n  <\n    const IncludeProps extends LayoutIncludeProps<\n      Resources,\n      Options,\n      Composables\n    > = {},\n    CustomProps extends InPropsObject = {},\n  >(\n    layout: Omit<\n      CreateViewMapFunctionRenderOptions<\n        Resources,\n        Options,\n        Composables,\n        IncludeProps,\n        CustomProps\n      >['layout'],\n      'composables'\n    >,\n  ): DefinedResourceLayout<\n    Resources,\n    Options,\n    Composables,\n    IncludeProps,\n    CustomProps,\n    {}\n  >;\n  /**\n   * Defines a layout whose `render` map contains the required `default` state\n   * and any built-in or custom compound component states.\n   */\n  <\n    const IncludeProps extends LayoutIncludeProps<\n      Resources,\n      Options,\n      Composables\n    > = {},\n    CustomProps extends InPropsObject = {},\n    DefaultComposables extends ComposableComponents = {},\n    const DefaultIncludeProps extends LayoutIncludeProps<\n      Resources,\n      Options,\n      Composables & DefaultComposables\n    > = {},\n    DefaultCustomProps extends InPropsObject = {},\n    LoadingComposables extends ComposableComponents = {},\n    const LoadingIncludeProps extends LayoutIncludeProps<\n      Resources,\n      Options,\n      Composables & LoadingComposables\n    > = {},\n    LoadingCustomProps extends InPropsObject = {},\n    ErrorComposables extends ComposableComponents = {},\n    const ErrorIncludeProps extends LayoutIncludeProps<\n      Resources,\n      Options,\n      Composables & ErrorComposables\n    > = {},\n    ErrorCustomProps extends InPropsObject = {},\n    NotFoundComposables extends ComposableComponents = {},\n    const NotFoundIncludeProps extends LayoutIncludeProps<\n      Resources,\n      Options,\n      Composables & NotFoundComposables\n    > = {},\n    NotFoundCustomProps extends InPropsObject = {},\n    const RenderStates extends { default: unknown } & Record<string, unknown> = {\n      default: unknown;\n    },\n  >(\n    layout: Omit<\n      CreateViewMapBuiltInRenderStatesOptions<\n        Resources,\n        Options,\n        Composables,\n        IncludeProps,\n        CustomProps,\n        TypedBuiltInRenderStates<\n          Resources,\n          Options,\n          Composables,\n          DefaultComposables,\n          DefaultIncludeProps,\n          DefaultCustomProps,\n          LoadingComposables,\n          LoadingIncludeProps,\n          LoadingCustomProps,\n          ErrorComposables,\n          ErrorIncludeProps,\n          ErrorCustomProps,\n          NotFoundComposables,\n          NotFoundIncludeProps,\n          NotFoundCustomProps\n        > & RenderStates\n      >['layout'],\n      'composables'\n    >,\n  ): DefinedResourceLayout<\n    Resources,\n    Options,\n    Composables &\n      DefaultComposables &\n      LoadingComposables &\n      ErrorComposables &\n      NotFoundComposables,\n    DefaultIncludeProps &\n      LoadingIncludeProps &\n      ErrorIncludeProps &\n      NotFoundIncludeProps,\n    DefaultCustomProps &\n      IncludedComponentPropDefinitions<\n        MergedLayoutInProps<\n          Resources,\n          Options,\n          Composables & DefaultComposables\n        >,\n        DefaultIncludeProps\n      >,\n    RenderStates\n  >;\n  /**\n   * Creates a lazy proxy for the single library-defined component exported by\n   * a resource module.\n   *\n   * @param options - Resource path and named-module import callback.\n   */\n  lazy<Module extends Record<string, unknown>>(\n    options: LazyResourceLayoutOptions<Resources, Module>,\n  ): ReturnType<typeof createLazyResourceLayout<Resources, Module>>;\n};\n\n/** Registers loading and module-error components used by lazy layouts. */\nexport type DefineLazyDefaults = {\n  /**\n   * Sets defaults once, before the factory creates its first lazy layout.\n   *\n   * @param defaults - Shared components for pending module loads and failures.\n   */\n  (defaults: LazyResourceStates): void;\n};\n\n/** Reusable helpers produced by {@link createDefinedResourceLayout}. */\nexport type CreateDefinedResourceLayoutResult<\n  Resources extends NonEmptyResources,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n> = {\n  /** Creates eager, deferred, or separately imported render-state fragments. */\n  createRenderState: CreateRenderState<Resources, Options, Composables>;\n  /** Sets the shared loading and module-error UI used by lazy layouts. */\n  defineLazyDefaults: DefineLazyDefaults;\n  /** Defines a layout using the resources, options, and composables already bound. */\n  defineResourceLayout: BoundDefineResourceLayout<\n    Resources,\n    Options,\n    Composables\n  >;\n  /** Reads, selects, or validates the resources bound to this factory. */\n  resources: LayoutResourcesAccessor<Resources>;\n};\n\n/**\n * Creates type-linked layout helpers from one shared configuration. The returned\n * `defineResourceLayout` accepts the layout directly, while `createRenderState`\n * carries the same resource and option types across file boundaries.\n *\n * @param configuration - Resources and optional shared props/composables to\n * bind to every returned helper.\n * @returns Helpers that share the configuration's inferred literal types.\n *\n * @example\n * ```tsx\n * const { createRenderState, defineResourceLayout } =\n *   createDefinedResourceLayout({\n *     resources: ['users'],\n *     options: { title: createProp.string() },\n *   });\n *\n * const Loading = createRenderState({\n *   state: 'Loading',\n *   props: { include: { title: true } },\n *   render: ({ title }) => <p>Loading {title}</p>,\n * });\n *\n * export const usersLayout = defineResourceLayout({\n *   render: { default: () => <Users />, ...Loading },\n * });\n * ```\n */\nexport function createDefinedResourceLayout<\n  const Resources extends NonEmptyResources,\n  const Options extends InPropsDefinition<Resources> = {},\n  Composables extends ComposableComponents = {},\n>(\n  configuration: CreateDefinedResourceLayoutOptions<\n    Resources,\n    Options,\n    Composables\n  >,\n): CreateDefinedResourceLayoutResult<Resources, Options, Composables> {\n  const { resources, options = {} as Options, composables } = configuration;\n  const defineBoundLayout = defineResourceLayout.forResources(...resources);\n  let lazyDefaults: LazyResourceStates = {};\n  let lazyDefaultsDefined = false;\n  let lazyLayoutCreated = false;\n\n  function defineLazyDefaults(defaults: LazyResourceStates): void {\n    if (lazyDefaultsDefined) {\n      throw new LayoutConfigurationError(\n        'Lazy resource defaults can only be defined once.',\n      );\n    }\n\n    if (lazyLayoutCreated) {\n      throw new LayoutConfigurationError(\n        'Lazy resource defaults must be defined before creating a lazy resource layout.',\n      );\n    }\n\n    lazyDefaults = defaults;\n    lazyDefaultsDefined = true;\n  }\n\n  const boundDefineResourceLayout = ((layout: Record<string, unknown>) =>\n    defineBoundLayout({\n      options,\n      layout: { ...layout, composables },\n    } as never)) as unknown as BoundDefineResourceLayout<\n    Resources,\n    Options,\n    Composables\n  >;\n\n  boundDefineResourceLayout.lazy = <Module extends Record<string, unknown>>(\n    lazyOptions: LazyResourceLayoutOptions<Resources, Module>,\n  ): ReturnType<typeof createLazyResourceLayout<Resources, Module>> => {\n    lazyLayoutCreated = true;\n    return createLazyResourceLayout(lazyOptions, lazyDefaults);\n  };\n\n  return {\n    createRenderState: createRenderStateBuilder({\n      composables,\n      options,\n      resources,\n    }),\n    defineLazyDefaults,\n    defineResourceLayout: boundDefineResourceLayout,\n    resources: createLayoutResourcesAccessor(resources),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuQA,SAAgB,4BAKd,eAKoE;CACpE,MAAM,EAAE,WAAW,UAAU,CAAC,GAAc,gBAAgB;CAC5D,MAAM,oBAAoB,qBAAqB,aAAa,GAAG,SAAS;CACxE,IAAI,eAAmC,CAAC;CACxC,IAAI,sBAAsB;CAC1B,IAAI,oBAAoB;CAExB,SAAS,mBAAmB,UAAoC;EAC9D,IAAI,qBACF,MAAM,IAAI,yBACR,kDACF;EAGF,IAAI,mBACF,MAAM,IAAI,yBACR,gFACF;EAGF,eAAe;EACf,sBAAsB;CACxB;CAEA,MAAM,8BAA8B,WAClC,kBAAkB;EAChB;EACA,QAAQ;GAAE,GAAG;GAAQ;EAAY;CACnC,CAAU;CAMZ,0BAA0B,QACxB,gBACmE;EACnE,oBAAoB;EACpB,OAAO,yBAAyB,aAAa,YAAY;CAC3D;CAEA,OAAO;EACL,mBAAmB,yBAAyB;GAC1C;GACA;GACA;EACF,CAAC;EACD;EACA,sBAAsB;EACtB,WAAW,8BAA8B,SAAS;CACpD;AACF"}
+{"version":3,"file":"create-defined-resource-layout.mjs","names":[],"sources":["../../src/create-config/create-defined-resource-layout.ts"],"sourcesContent":["import type { ComposableComponents, CreateLayoutComposable } from '@jfdevelops/react-layout-composables';\nimport { LayoutConfigurationError } from '../errors';\nimport type { InPropsDefinition, InPropsObject } from '../props';\nimport type { LayoutResourceKey, ResourceDefinition } from '../resource';\nimport {\n  type CreateViewMapFunctionRenderOptions,\n  type DefinedResourceLayout,\n  defineResourceLayout,\n  type LayoutIncludeProps,\n  type LayoutResourcesAccessor,\n  type CreateViewMapRenderStatesOptions,\n  type DefinedResourceLayoutFromStates,\n  createLayoutResourcesAccessor,\n} from './define-layout';\nimport {\n  createLazyResourceLayout,\n  type LazyResourceLayoutOptions,\n  type LazyResourceStates,\n} from './lazy-resource-layout';\nimport {\n  createRenderStateBuilder,\n  type CreateRenderState,\n  type RenderStateReferences,\n  type LayoutComposablesDefinition,\n} from './render-state';\n\n/** A resource tuple with at least one entry, preserving literal and nested paths. */\nexport type NonEmptyResources = readonly [\n  ResourceDefinition,\n  ...ResourceDefinition[],\n];\n\n/** Configuration shared by every layout created from one defined-layout factory. */\nexport type CreateDefinedResourceLayoutOptions<\n  Resources extends NonEmptyResources,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n  DefaultNamespace extends boolean = false,\n> = {\n  namespace?: DefaultNamespace;\n  /** Resources supported by every layout created from this factory. */\n  resources: Resources;\n  /** Props that render states can opt into through `props.include`. */\n  options?: Options;\n  /** Layout-wide composables available to every render state. */\n  composables?: LayoutComposablesDefinition<Resources, Composables>;\n};\n\n/** The flat layout definition accepted after shared configuration is bound. */\nexport type DefinedResourceLayoutInput<\n  Resources extends NonEmptyResources,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n  IncludeProps extends LayoutIncludeProps<Resources, Options, Composables>,\n  CustomProps extends InPropsObject,\n  Render,\n  Namespace extends boolean = false,\n> = Omit<\n  CreateViewMapFunctionRenderOptions<\n    Resources,\n    Options,\n    Composables,\n    IncludeProps,\n    CustomProps\n  >['layout'],\n  'composables' | 'render'\n> & { render: Render; namespace?: Namespace };\n\ntype BoundLayoutComposables<\n  Shared extends ComposableComponents,\n  Local extends ComposableComponents,\n> = Omit<Shared, keyof Local> & Local;\n\n/** Flattens a definition's layout while preserving its namespace setting. */\ntype BoundLayoutInput<Definition extends { layout: unknown; namespace?: boolean }> =\n  Definition['layout'] & Pick<Definition, 'namespace'>;\n\n/** A `defineResourceLayout` function with its shared configuration pre-bound. */\nexport type BoundDefineResourceLayout<\n  Resources extends NonEmptyResources,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n  DefaultNamespace extends boolean = false,\n> = {\n  /**\n   * Defines a layout whose `render` map contains the required `default` state\n   * and any built-in or custom compound component states.\n   * Keep this overload first so incomplete render objects suggest state keys.\n   * Use `createRenderState` for state-local `composables(create)` callbacks;\n   * the helper infers their render context independently of the enclosing map.\n   */\n  <\n    const Render extends { default: unknown } & Record<string, unknown>,\n    LocalComposables extends ComposableComponents = {},\n    Namespace extends boolean = DefaultNamespace,\n  >(\n    layout: Omit<\n      BoundLayoutInput<CreateViewMapRenderStatesOptions<Resources, Options, BoundLayoutComposables<Composables, LocalComposables>, {}, {}, Render, Namespace>>,\n      'composables'\n    > & {\n      composables?: (\n        create: CreateLayoutComposable<LayoutResourceKey<Resources>>,\n        states: RenderStateReferences<Resources, Options, Composables, Render>,\n      ) => LocalComposables;\n    },\n  ): DefinedResourceLayoutFromStates<Resources, Options, BoundLayoutComposables<Composables, LocalComposables>, Render, Namespace>;\n  /** Defines a layout whose `render` value is a single default-state callback. */\n  <\n    const IncludeProps extends LayoutIncludeProps<\n      Resources,\n      Options,\n      BoundLayoutComposables<Composables, LocalComposables>\n    > = {},\n    CustomProps extends InPropsObject = {},\n    LocalComposables extends ComposableComponents = {},\n    Namespace extends boolean = DefaultNamespace,\n  >(\n    layout: Omit<\n      BoundLayoutInput<CreateViewMapFunctionRenderOptions<\n        Resources,\n        Options,\n        BoundLayoutComposables<Composables, LocalComposables>,\n        IncludeProps,\n        CustomProps,\n        Namespace\n      >>,\n      'composables'\n    > & {\n      composables?: (\n        create: CreateLayoutComposable<LayoutResourceKey<Resources>>,\n        states: {},\n      ) => LocalComposables;\n    },\n  ): DefinedResourceLayout<\n    Resources,\n    Options,\n    BoundLayoutComposables<Composables, LocalComposables>,\n    IncludeProps,\n    CustomProps,\n    {},\n    Namespace\n  >;\n  /**\n   * Creates a lazy proxy for the single library-defined component exported by\n   * a resource module.\n   *\n   * @param options - Resource path and named-module import callback.\n   */\n  lazy<Module extends Record<string, unknown>>(\n    options: LazyResourceLayoutOptions<Resources, Module>,\n  ): ReturnType<typeof createLazyResourceLayout<Resources, Module>>;\n};\n\n/** Registers loading and module-error components used by lazy layouts. */\nexport type DefineLazyDefaults = {\n  /**\n   * Sets defaults once, before the factory creates its first lazy layout.\n   *\n   * @param defaults - Shared components for pending module loads and failures.\n   */\n  (defaults: LazyResourceStates): void;\n};\n\n/** Reusable helpers produced by {@link createDefinedResourceLayout}. */\nexport type CreateDefinedResourceLayoutResult<\n  Resources extends NonEmptyResources,\n  Options extends InPropsDefinition<Resources>,\n  Composables extends ComposableComponents,\n  DefaultNamespace extends boolean = false,\n> = {\n  /** Creates eager, deferred, or separately imported render-state fragments. */\n  createRenderState: CreateRenderState<Resources, Options, Composables>;\n  /** Sets the shared loading and module-error UI used by lazy layouts. */\n  defineLazyDefaults: DefineLazyDefaults;\n  /** Defines a layout using the resources, options, and composables already bound. */\n  defineResourceLayout: BoundDefineResourceLayout<\n    Resources,\n    Options,\n    Composables,\n    DefaultNamespace\n  >;\n  /** Reads, selects, or validates the resources bound to this factory. */\n  resources: LayoutResourcesAccessor<Resources>;\n};\n\n/**\n * Creates type-linked layout helpers from one shared configuration. The returned\n * `defineResourceLayout` accepts the layout directly, while `createRenderState`\n * carries the same resource and option types across file boundaries.\n *\n * @param configuration - Resources and optional shared props/composables to\n * bind to every returned helper.\n * @returns Helpers that share the configuration's inferred literal types.\n *\n * @example\n * ```tsx\n * const { createRenderState, defineResourceLayout } =\n *   createDefinedResourceLayout({\n *     resources: ['users'],\n *     options: { title: createProp.string() },\n *   });\n *\n * const Loading = createRenderState({\n *   state: 'Loading',\n *   props: { include: { title: true } },\n *   render: ({ title }) => <p>Loading {title}</p>,\n * });\n *\n * export const usersLayout = defineResourceLayout({\n *   render: { default: () => <Users />, ...Loading },\n * });\n * ```\n */\nexport function createDefinedResourceLayout<\n  const Resources extends NonEmptyResources,\n  const Options extends InPropsDefinition<Resources> = {},\n  Composables extends ComposableComponents = {},\n  DefaultNamespace extends boolean = false,\n>(\n  configuration: CreateDefinedResourceLayoutOptions<\n    Resources,\n    Options,\n    Composables,\n    DefaultNamespace\n  >,\n): CreateDefinedResourceLayoutResult<Resources, Options, Composables, DefaultNamespace> {\n  const { resources, options = {} as Options, composables } = configuration;\n  const defineBoundLayout = defineResourceLayout.forResources(...resources);\n  let lazyDefaults: LazyResourceStates = {};\n  let lazyDefaultsDefined = false;\n  let lazyLayoutCreated = false;\n\n  function defineLazyDefaults(defaults: LazyResourceStates): void {\n    if (lazyDefaultsDefined) {\n      throw new LayoutConfigurationError(\n        'Lazy resource defaults can only be defined once.',\n      );\n    }\n\n    if (lazyLayoutCreated) {\n      throw new LayoutConfigurationError(\n        'Lazy resource defaults must be defined before creating a lazy resource layout.',\n      );\n    }\n\n    lazyDefaults = defaults;\n    lazyDefaultsDefined = true;\n  }\n\n  const boundDefineResourceLayout = ((layout: Record<string, unknown>) => {\n    const localComposables = layout.composables as LayoutComposablesDefinition<Resources, ComposableComponents> | undefined;\n    return defineBoundLayout({\n      options,\n      namespace: layout.namespace ?? configuration.namespace,\n      layout: {\n        ...layout,\n        composables: composables || localComposables\n          ? (create: CreateLayoutComposable<LayoutResourceKey<Resources>>, states: {}) => ({\n              ...composables?.(create, states),\n              ...localComposables?.(create, states),\n            })\n          : undefined,\n      },\n    } as never);\n  }) as unknown as BoundDefineResourceLayout<\n    Resources,\n    Options,\n    Composables,\n    DefaultNamespace\n  >;\n\n  boundDefineResourceLayout.lazy = <Module extends Record<string, unknown>>(\n    lazyOptions: LazyResourceLayoutOptions<Resources, Module>,\n  ): ReturnType<typeof createLazyResourceLayout<Resources, Module>> => {\n    lazyLayoutCreated = true;\n    return createLazyResourceLayout(lazyOptions, lazyDefaults);\n  };\n\n  return {\n    createRenderState: createRenderStateBuilder({\n      composables,\n      options,\n      resources,\n    }),\n    defineLazyDefaults,\n    defineResourceLayout: boundDefineResourceLayout,\n    resources: createLayoutResourcesAccessor(resources),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqNA,SAAgB,4BAMd,eAMsF;CACtF,MAAM,EAAE,WAAW,UAAU,CAAC,GAAc,gBAAgB;CAC5D,MAAM,oBAAoB,qBAAqB,aAAa,GAAG,SAAS;CACxE,IAAI,eAAmC,CAAC;CACxC,IAAI,sBAAsB;CAC1B,IAAI,oBAAoB;CAExB,SAAS,mBAAmB,UAAoC;EAC9D,IAAI,qBACF,MAAM,IAAI,yBACR,kDACF;EAGF,IAAI,mBACF,MAAM,IAAI,yBACR,gFACF;EAGF,eAAe;EACf,sBAAsB;CACxB;CAEA,MAAM,8BAA8B,WAAoC;EACtE,MAAM,mBAAmB,OAAO;EAChC,OAAO,kBAAkB;GACvB;GACA,WAAW,OAAO,aAAa,cAAc;GAC7C,QAAQ;IACN,GAAG;IACH,aAAa,eAAe,oBACvB,QAA8D,YAAgB;KAC7E,GAAG,cAAc,QAAQ,MAAM;KAC/B,GAAG,mBAAmB,QAAQ,MAAM;IACtC,KACA;GACN;EACF,CAAU;CACZ;CAOA,0BAA0B,QACxB,gBACmE;EACnE,oBAAoB;EACpB,OAAO,yBAAyB,aAAa,YAAY;CAC3D;CAEA,OAAO;EACL,mBAAmB,yBAAyB;GAC1C;GACA;GACA;EACF,CAAC;EACD;EACA,sBAAsB;EACtB,WAAW,8BAA8B,SAAS;CACpD;AACF"}

package/dist/create-config/define-layout.cjs

@@ -11,6 +11,7 @@ const require_create_resource_links = require('./create-resource-links.cjs');
 const require_for_resource = require('./for-resource.cjs');
 const require_create_for_resources = require('./for-resources/create-for-resources.cjs');
 const require_shell_context = require('./shell-context.cjs');
+const require_state_composable = require('./state-composable.cjs');
 const require_render_state = require('./render-state.cjs');
 let _jfdevelops_react_layout_composables = require("@jfdevelops/react-layout-composables");
 let react = require("react");
@@ -137,8 +138,8 @@ function assertUnreservedResourceSlugs(resources, owner) {
 		if (typeof resource !== "string") assertUnreservedResourceSlugs(resource.subResources, slug);
 	}
 }
-function defineResourceLayoutImpl(options) {
-	const { options: inProps = {}, resources, layout } = options;
+function defineResourceLayoutImpl(options, inheritedStateScope) {
+	const { options: inProps = {}, resources, layout, namespace: defaultNamespace = false } = options;
 	const shellId = options.shellId;
 	assertUnreservedResourceSlugs(resources);
 	const resourcesAccessor = createLayoutResourcesAccessor(resources);
@@ -157,7 +158,7 @@ function defineResourceLayoutImpl(options) {
 	const normalizedResources = require_resource.normalizeResources(resources);
 	const resourcesEnum = (0, _jfdevelops_react_layout_validator.createPrimitivePropBuilder)("string").enum(require_resource.toResourceEnum(normalizedResources));
 	const definedResourceLayout = ((layoutOptions) => {
-		const { name, props: instancePropDefinitions, ...layoutOptionProps } = layoutOptions;
+		const { name, props: instancePropDefinitions, namespace = defaultNamespace, ...layoutOptionProps } = layoutOptions;
 		const createComposableLayout = (0, _jfdevelops_react_layout_composables.makeComposable)();
 		const nameProp = _jfdevelops_react_layout_validator.createProp.string().literal(name);
 		const { resolvedInProps, splitInProps } = splitLayoutInProps({
@@ -170,6 +171,19 @@ function defineResourceLayoutImpl(options) {
 		});
 		const { composables, props: legacyLayoutProps } = layout;
 		const renderStates = typeof layout.render === "function" ? { default: layout.render } : layout.render;
+		const referenceComponents = /* @__PURE__ */ new Map();
+		const stateScope = inheritedStateScope ?? {
+			states: require_state_composable.createStateReferences(renderStates),
+			resolve(source) {
+				for (const [stateName, input] of Object.entries(renderStates)) if (input === source.input) return stateName === "default" ? Component : stateComponents[stateName];
+				let reference = referenceComponents.get(source.input);
+				if (!reference) {
+					reference = createStateComponent(source.name, source.input, false);
+					referenceComponents.set(source.input, reference);
+				}
+				return reference;
+			}
+		};
 		const defaultRenderInput = renderStates.default;
 		const createdDefaultState = require_render_state.isDeferredRenderState(defaultRenderInput) || require_render_state.isLazyRenderState(defaultRenderInput);
 		const defaultRenderDefinition = getSynchronousRenderStateDefinition(defaultRenderInput, legacyLayoutProps) ?? { render: () => null };
@@ -190,10 +204,10 @@ function defineResourceLayoutImpl(options) {
 			layoutName: name,
 			resource: layoutContext.resource
 		};
-		const defaultComposables = defaultState.composables ? (create) => ({
-			...composables?.(create) ?? {},
-			...defaultState.composables?.(create)
-		}) : composables;
+		const defaultComposables = composables || defaultState.composables ? (create) => ({
+			...composables?.(create, stateScope.states) ?? {},
+			...defaultState.composables?.(create, stateScope.states)
+		}) : void 0;
 		const resolvedComposables = defaultComposables ? (0, _jfdevelops_react_layout_composables.resolveLayoutComposables)(defaultComposables, layoutContext) : void 0;
 		const mergedResolvedInProps = { ...resolvedInProps };
 		for (const { props: presetPropDefinitions } of (0, _jfdevelops_react_layout_composables.collectComposablePresetEntries)(resolvedComposables)) Object.assign(mergedResolvedInProps, presetPropDefinitions);
@@ -254,7 +268,13 @@ function defineResourceLayoutImpl(options) {
 				resource: layoutContext.resource,
 				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_jfdevelops_react_layout_composables.LayoutComposablePresetProvider, {
 					value: composablePresetProps,
-					children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RenderDefaultState, { renderProps: layoutRenderProps })
+					children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_state_composable.StateComposableContext.Provider, {
+						value: {
+							scope: stateScope,
+							props: layoutRenderProps
+						},
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RenderDefaultState, { renderProps: layoutRenderProps })
+					})
 				})
 			});
 			const ErrorComponent = stateComponents.Error;
@@ -273,7 +293,7 @@ function defineResourceLayoutImpl(options) {
 			if (!compositionOptions.components) return {};
 			return { makeComposable: createComposableLayout(compositionOptions) };
 		}
-		function createStateComponent(stateName, input) {
+		function createStateComponent(stateName, input, validateStateName = true) {
 			if (require_render_state.isLazyRenderState(input)) {
 				const loadState = input[require_render_state.lazyRenderStateSymbol];
 				function createLazyState() {
@@ -281,8 +301,8 @@ function defineResourceLayoutImpl(options) {
 						const stateDefinition = require_render_state.findDefinedRenderState(await loadState().catch((error) => {
 							throw new require_resource_state_error.ResourceModuleLoadError(String(layoutContext.resource), error);
 						}));
-						if (stateDefinition.state !== void 0 && stateDefinition.state !== stateName) throw new require_layout_configuration_error.LayoutConfigurationError(`Lazy render state "${stateDefinition.state}" cannot be used as "${stateName}"`);
-						return { default: createLoadedStateComponent(stateName, stateDefinition) };
+						if (validateStateName && stateDefinition.state !== void 0 && stateDefinition.state !== stateName) throw new require_layout_configuration_error.LayoutConfigurationError(`Lazy render state "${stateDefinition.state}" cannot be used as "${stateName}"`);
+						return { default: createLoadedStateComponent(validateStateName ? stateName : stateDefinition.state ?? stateName, stateDefinition) };
 					});
 				}
 				function LazyStateComponent(props) {
@@ -339,10 +359,10 @@ function defineResourceLayoutImpl(options) {
 			return DeferredStateComponent;
 		}
 		function createLoadedStateComponent(stateName, definition) {
-			const stateComposables = definition.composables ? (create) => ({
-				...composables?.(create) ?? {},
-				...definition.composables?.(create)
-			}) : composables;
+			const stateComposables = composables || definition.composables ? (create) => ({
+				...composables?.(create, stateScope.states) ?? {},
+				...definition.composables?.(create, stateScope.states)
+			}) : void 0;
 			const stateRender = stateName === "Error" ? (props, context) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RenderStateRetryContext.Consumer, { children: (retry) => definition.render(props, {
 				...context,
 				retry
@@ -355,7 +375,10 @@ function defineResourceLayoutImpl(options) {
 					props: definition.props,
 					render: stateRender
 				}
-			}).createResourceLayout(layoutOptions);
+			}, stateScope).createResourceLayout({
+				...layoutOptions,
+				namespace: false
+			});
 			StateComponent.displayName = `${name}.${stateName}`;
 			return StateComponent;
 		}
@@ -364,6 +387,7 @@ function defineResourceLayoutImpl(options) {
 			if (stateName === "default") continue;
 			if ([
 				"__proto__",
+				"asComposable",
 				"apply",
 				"arguments",
 				"bind",
@@ -384,7 +408,7 @@ function defineResourceLayoutImpl(options) {
 			const definition = mergedResolvedInProps[key];
 			return [[key, isIncludedPropRequired(includeLayoutProps?.[key]) ? definition : definition.optional?.() ?? definition]];
 		}));
-		return (0, _jfdevelops_react_layout_validator.attachComponentPropDefinitions)(Object.assign(Component, {
+		const rootComponent = (0, _jfdevelops_react_layout_validator.attachComponentPropDefinitions)(Object.assign(Component, {
 			displayName: name,
 			props: void 0,
 			resource: void 0,
@@ -398,10 +422,21 @@ function defineResourceLayoutImpl(options) {
 			...customLayoutProps,
 			...includedComponentDefinitions
 		});
+		if (namespace) {
+			if (Object.prototype.hasOwnProperty.call(stateComponents, "Root")) throw new require_layout_configuration_error.LayoutConfigurationError("Render state name \"Root\" is reserved when namespace is true");
+			return {
+				Root: rootComponent,
+				...stateComponents
+			};
+		}
+		return rootComponent;
 	});
 	const createTopLevelMakeComposable = () => {
 		return (options) => {
-			const layout = definedResourceLayout(options);
+			const layout = definedResourceLayout({
+				...options,
+				namespace: false
+			});
 			if (!("makeComposable" in layout) || typeof layout.makeComposable !== "function") throw new require_layout_configuration_error.LayoutConfigurationError("makeComposable requires composables to be defined in the layout");
 			return layout.makeComposable();
 		};
@@ -412,11 +447,13 @@ function defineResourceLayoutImpl(options) {
 			resource: resourcesEnum,
 			name: _jfdevelops_react_layout_validator.createProp.string().literal(componentName)
 		}) : inProps);
-		const defaultState = getSynchronousRenderStateDefinition((typeof layout.render === "function" ? { default: layout.render } : layout.render).default, layout.props);
-		const defaultComposables = defaultState?.composables ? (create) => ({
-			...layout.composables?.(create) ?? {},
-			...defaultState.composables?.(create)
-		}) : layout.composables;
+		const renderStates = typeof layout.render === "function" ? { default: layout.render } : layout.render;
+		const defaultState = getSynchronousRenderStateDefinition(renderStates.default, layout.props);
+		const stateReferences = require_state_composable.createStateReferences(renderStates);
+		const defaultComposables = layout.composables || defaultState?.composables ? (create) => ({
+			...layout.composables?.(create, stateReferences) ?? {},
+			...defaultState?.composables?.(create, stateReferences)
+		}) : void 0;
 		const resolvedComposables = defaultComposables ? (0, _jfdevelops_react_layout_composables.resolveLayoutComposables)(defaultComposables, {
 			resource,
 			name: componentName,
@@ -619,6 +656,7 @@ function defineResourceLayoutWithLayoutImpl(options) {
 		resources,
 		options: inProps,
 		layout: resolvedLayout,
+		namespace: options.namespace,
 		shellId
 	});
 	const Shell = createResourceLayoutShellComponent(resources, inProps ?? {}, shell, shellId);