nuance-ui 0.2.6 → 0.2.7

package/dist/runtime/components/tree/_ui/tree-item.vue.d.ts

@@ -1,4 +1,4 @@
-import type { TreeItem } from '../model.js';
+import type { TreeItem } from '../types.js';
 export interface TreeItemProps extends TreeItem {
     level: number;
 }

package/dist/runtime/components/tree/_ui/tree-root.d.vue.ts

@@ -1,6 +1,6 @@
 import type { ButtonProps } from '@nui/components';
 import type { RovingFocusProps } from '../../roving-focus/roving-focus.vue.js';
-import type { TreeFilter, TreeIconResolver, TreeLoader, TreeModels } from '../model.js';
+import type { TreeFilter, TreeIconResolver, TreeLoader, TreeModels } from '../types.js';
 export type TreeRootProps = RovingFocusProps & {
     iconResolver?: TreeIconResolver;
     removable?: boolean;

package/dist/runtime/components/tree/_ui/tree-root.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { useStyleResolver } from "@nui/composals";
+import { useStyleResolver } from "@nui/composables";
 import { getSize } from "@nui/utils";
 import { onClickOutside, useEventListener } from "@vueuse/core";
 import { useTemplateRef } from "vue";

package/dist/runtime/components/tree/_ui/tree-root.vue.d.ts

@@ -1,6 +1,6 @@
 import type { ButtonProps } from '@nui/components';
 import type { RovingFocusProps } from '../../roving-focus/roving-focus.vue.js';
-import type { TreeFilter, TreeIconResolver, TreeLoader, TreeModels } from '../model.js';
+import type { TreeFilter, TreeIconResolver, TreeLoader, TreeModels } from '../types.js';
 export type TreeRootProps = RovingFocusProps & {
     iconResolver?: TreeIconResolver;
     removable?: boolean;

package/dist/runtime/components/tree/index.d.ts

@@ -1 +1 @@
-export * from './model.js';
+export * from './types.js';

package/dist/runtime/components/tree/index.js

@@ -1 +1 @@
-export * from "./model.js";
+export * from "./types.js";

package/dist/runtime/components/tree/lib/context.d.ts

@@ -1,6 +1,6 @@
 import type { ButtonProps } from '@nui/components';
 import type { ModelRef, ShallowRef } from 'vue';
-import type { TreeFilter, TreeIconResolver, TreeLoader } from '../model.js';
+import type { TreeFilter, TreeIconResolver, TreeLoader } from '../types.js';
 type EventType = 'select' | 'expand';
 type SelectMode = 'single' | 'multiple' | 'range';
 export interface TreeContext {

package/dist/runtime/components/tree/lib/context.js

@@ -1,4 +1,4 @@
-import { createStrictInjection } from "@nui/helpers";
+import { createStrictInjection } from "@nui/composables";
 import { unrefElement } from "@vueuse/core";
 const injectionKey = Symbol("nui-tree");
 const [useProvide, useState] = createStrictInjection(({

package/dist/runtime/components/tree/lib/filter-tree-items.d.ts

@@ -1,2 +1,2 @@
-import type { TreeFilter, TreeItem } from '../model.js';
+import type { TreeFilter, TreeItem } from '../types.js';
 export declare function filterTreeItems(items: TreeItem[] | undefined, filter?: TreeFilter): TreeItem[] | undefined;

package/dist/runtime/components/tree/tree.d.vue.ts

@@ -1,5 +1,5 @@
 import type { TreeRootProps } from './_ui/tree-root.vue.js';
-import type { TreeModels } from './model.js';
+import type { TreeModels } from './types.js';
 export interface TreeProps extends TreeRootProps {
 }
 type __VLS_Props = TreeProps;

package/dist/runtime/components/tree/tree.vue

@@ -33,24 +33,24 @@ onMounted(execute);
 </script>
 
 <template>
-	<TreeRoot
-		v-bind='props'
-		v-model:active='active'
-		v-model:selected='selected'
-		v-model:expanded='expanded'
-		:load-branch
-		:size
-		:color
-		:variant
-		:filter
-		@delete='(path) => $emit("delete", path)'
-	>
-		<UTreeItem
-			v-for='item in root'
-			:key='item.path'
-			v-bind='item'
-			:path='item.path'
-			:level='1'
-		/>
-	</TreeRoot>
+	<TreeRoot
+		v-bind='props'
+		v-model:active='active'
+		v-model:selected='selected'
+		v-model:expanded='expanded'
+		:load-branch
+		:size
+		:color
+		:variant
+		:filter
+		@delete='(path) => $emit("delete", path)'
+	>
+		<UTreeItem
+			v-for='item in root'
+			:key='item.path'
+			v-bind='item'
+			:path='item.path'
+			:level='1'
+		/>
+	</TreeRoot>
 </template>

package/dist/runtime/components/tree/tree.vue.d.ts

@@ -1,5 +1,5 @@
 import type { TreeRootProps } from './_ui/tree-root.vue.js';
-import type { TreeModels } from './model.js';
+import type { TreeModels } from './types.js';
 export interface TreeProps extends TreeRootProps {
 }
 type __VLS_Props = TreeProps;

package/dist/runtime/components/visually-hidden/visually-hidden-input.d.vue.ts

@@ -1,6 +1,7 @@
 import type { VisuallyHiddenProps } from './visually-hidden.vue.js';
 export interface VisuallyHiddenInputProps extends VisuallyHiddenProps {
-    name: string;
+    /** Input name */
+    name?: string;
     required?: boolean;
     disabled?: boolean;
 }

package/dist/runtime/components/visually-hidden/visually-hidden-input.vue

@@ -1,7 +1,7 @@
 <script setup>
 import VisuallyHidden from "./visually-hidden.vue";
 const props = defineProps({
-  name: { type: String, required: true },
+  name: { type: String, required: false },
   required: { type: Boolean, required: false },
   disabled: { type: Boolean, required: false },
   feature: { type: String, required: false },
@@ -12,5 +12,5 @@ const value = defineModel({ type: null });
 </script>
 
 <template>
-	<VisuallyHidden v-bind='{ ...props, ...$attrs }' is='input' v-model='value' />
+	<VisuallyHidden v-bind='{ ...props, ...$attrs }' is='input' v-model='value' />
 </template>

package/dist/runtime/components/visually-hidden/visually-hidden-input.vue.d.ts

@@ -1,6 +1,7 @@
 import type { VisuallyHiddenProps } from './visually-hidden.vue.js';
 export interface VisuallyHiddenInputProps extends VisuallyHiddenProps {
-    name: string;
+    /** Input name */
+    name?: string;
     required?: boolean;
     disabled?: boolean;
 }

package/dist/runtime/composables/create-strict-injection.d.ts

@@ -0,0 +1,42 @@
+import type { InjectionKey } from '@vue/runtime-core';
+import type { CreateInjectionStateOptions } from '@vueuse/core';
+interface StrictInjectionOptions<Return> extends Omit<CreateInjectionStateOptions<Return>, 'injectionKey'> {
+    /** Human-readable context name embedded into the missing-provider error message. */
+    name: string;
+    /** Vue injection key used to store and read the provided state. */
+    injectionKey: InjectionKey<Return>;
+}
+type StrictInjectionReturn<Arguments extends Array<any>, Return> = Readonly<[
+    /**
+     * Provider function to be called in a parent component.
+     * Creates and provides the state to all descendant components.
+     */
+    useProvidingState: (...args: Arguments) => Return,
+    /**
+     * Consumer function to be called in a child component.
+     * Injects the state provided by the nearest parent provider.
+     *
+     * @throws {Error} When called outside of a provider context
+     */
+    useInjectedState: () => Return
+]>;
+/**
+ * Creates a strict provide/inject.
+ *
+ * Unlike Vue's standard `inject`, the returned consumer hook throws a
+ * descriptive error when called outside of a provider, so misuse surfaces
+ * immediately instead of producing silent `undefined` values downstream.
+ *
+ * @example
+ * ```ts
+ * const [useProvideComboboxState, useComboboxState] = createStrictInjection(
+ *   (state: ComboboxState) => ({
+ *     ...state,
+ *     select: (item: string) => { state.selected.value = item },
+ *   }),
+ *   { name: 'ComboboxState', injectionKey: Symbol('combobox-state') },
+ * )
+ * ```
+ */
+export declare function createStrictInjection<Arguments extends Array<any>, Return>(composable: (...args: Arguments) => Return, options: StrictInjectionOptions<Return>): StrictInjectionReturn<Arguments, Return>;
+export {};

package/dist/runtime/{composals → composables}/index.d.ts

@@ -1,4 +1,6 @@
+export * from './create-strict-injection.js';
 export * from './use-active-link.js';
 export * from './use-date-config.js';
+export * from './use-selectable-group.js';
 export * from './use-style-resolver.js';
 export * from './use-theme.js';

package/dist/runtime/{composals → composables}/index.js

@@ -1,4 +1,6 @@
+export * from "./create-strict-injection.js";
 export * from "./use-active-link.js";
 export * from "./use-date-config.js";
+export * from "./use-selectable-group.js";
 export * from "./use-style-resolver.js";
 export * from "./use-theme.js";

package/dist/runtime/composables/use-active-link.d.ts

@@ -0,0 +1,15 @@
+import type { ComputedRef } from 'vue';
+import type { RouteLocationRaw } from 'vue-router';
+/**
+ * Computes whether a given route target matches the current route.
+ *
+ * By default the link is active when its resolved path equals the current
+ * path or is a prefix of it, so parent routes stay highlighted while
+ * browsing nested children.
+ *
+ * Pass `exact: true` to disable prefix matching.
+ */
+export declare function useActiveLink(href: RouteLocationRaw | undefined, options?: {
+    /** Require a strict path equality instead of prefix matching. */
+    exact?: boolean;
+}): ComputedRef<boolean>;

package/dist/runtime/{composals → composables}/use-date-config.d.ts

@@ -1,5 +1,7 @@
 import type { FormatOptions } from '@formkit/tempo';
+/** Locale configuration for date-aware features. */
 export type DateConfig = Omit<FormatOptions, 'date' | 'format'> & {
+    /** Index of the first day of the week (0 = Sunday, 1 = Monday, ...). */
     firstDayOfWeek: number;
 };
 declare const Inject: () => {
@@ -10,8 +12,11 @@ declare const Inject: () => {
     partFilter?: (part: import("@formkit/tempo").Part) => boolean;
 } | undefined;
 /**
- * Hook to provide the dates configuration in a root or parent component.
- * Necessary for initializing the configuration that will be used by child components.
+ * Provides the shared date configuration to the component subtree.
+ *
+ * Call once in a root or layout component.
+ *
+ * When `firstDayOfWeek` is omitted, it is resolved from the locale.
  */
 export declare const useProvideDatesConfig: (state?: Partial<DateConfig> | undefined) => {
     firstDayOfWeek: number;
@@ -21,10 +26,10 @@ export declare const useProvideDatesConfig: (state?: Partial<DateConfig> | undef
     partFilter?: (part: import("@formkit/tempo").Part) => boolean;
 };
 /**
- * Hook to inject the dates configuration in a component.
- * Used in components that depend on the dates configuration.
+ * Reads the shared date configuration provided by `useProvideDatesConfig`.
  *
- * @param localValue merges new values with ctx with `defu`
+ * A local override can be passed in and will be shallow-merged on top of the
+ * injected config.
  */
 export declare function useDatesConfig(localValue?: ReturnType<typeof Inject>): {
     firstDayOfWeek: number;

package/dist/runtime/composables/use-selectable-group.d.ts

@@ -0,0 +1,23 @@
+import type { ModelRef } from 'vue';
+export interface UseSelectableGroupOptions {
+    /** When `true`, the value cannot be changed. */
+    readOnly?: boolean;
+    /** When `true`, all items in the group are disabled. */
+    disabled?: boolean;
+    /** Maximum number of items that can be selected. When reached, unselected items become disabled. */
+    maxSelectedValues?: number;
+}
+export interface UseSelectableGroupReturn<T> {
+    /** Toggles the given value in the selection array. */
+    update: (value: T) => void;
+    /** Returns `true` when the value is currently selected. */
+    isSelected: (value: T) => boolean;
+    /** Returns `true` when an item with the given value should be disabled. */
+    isDisabled: (value: T) => boolean;
+}
+/**
+ * Shared selection logic for multi-select group components.
+ *
+ * Centralizes the add/remove, max-limit and read-only rules.
+ */
+export declare function useSelectableGroup<T extends string = string>(value: ModelRef<T[]>, options?: UseSelectableGroupOptions): UseSelectableGroupReturn<T>;

package/dist/runtime/composables/use-selectable-group.js

@@ -0,0 +1,20 @@
+export function useSelectableGroup(value, options = {}) {
+  const isSelected = (item) => value.value.includes(item);
+  const update = (item) => {
+    if (options.readOnly)
+      return;
+    const selected = isSelected(item);
+    if (!selected && options.maxSelectedValues !== void 0 && value.value.length >= options.maxSelectedValues) {
+      return;
+    }
+    value.value = selected ? value.value.filter((i) => i !== item) : [...value.value, item];
+  };
+  const isDisabled = (item) => {
+    if (options.disabled)
+      return true;
+    if (options.maxSelectedValues === void 0)
+      return false;
+    return !isSelected(item) && value.value.length >= options.maxSelectedValues;
+  };
+  return { update, isSelected, isDisabled };
+}

package/dist/runtime/{composals → composables}/use-style-resolver.d.ts

@@ -1,3 +1,6 @@
 import type { NuanceTheme } from '@nui/types';
 import type { CSSProperties } from 'vue';
+/**
+ * Builds a style object from a factory that receives the current theme.
+ */
 export declare function useStyleResolver<T extends CSSProperties>(factory: (theme: NuanceTheme) => T): T;

package/dist/runtime/composables/use-theme.d.ts

@@ -0,0 +1,16 @@
+import type { NuanceTheme } from '@nui/types';
+interface ThemeInstance {
+    /** User-selected theme preference, including `system`. Writable. */
+    preference: NuanceTheme;
+    /** Resolved theme currently applied to the document. */
+    readonly value: NuanceTheme;
+    /** `true` while the theme has not yet been determined on the client. */
+    unknown: boolean;
+    /** `true` when the theme is forced by the application and cannot be changed by the user. */
+    forced: boolean;
+}
+/**
+ * Returns the current Nuance theme instance
+ */
+export declare function useTheme(): ThemeInstance;
+export {};

package/dist/runtime/modals/_confirm-modal/confirm-modal.d.vue.ts

@@ -1,5 +1,5 @@
+import type { MaybePromise } from '@nui/types';
 import type { ButtonProps, ModalRootProps } from '../../components/index.js';
-import type { MaybePromise } from '../../types/index.js';
 type ConfirmLabels = Record<'confirm' | 'cancel', string>;
 export interface ConfirmModalProps extends /* @vue-ignore */ ModalRootProps {
     /** Modal title */

package/dist/runtime/modals/_confirm-modal/confirm-modal.vue

@@ -45,37 +45,37 @@ async function hanleConfirm() {
 </script>
 
 <template>
-	<ModalRoot v-model:open='opened' v-bind='rest' :close-on-click-outside size='sm'>
-		<ModalHeader>
-			<Title order='4'>
-				{{ title }}
-			</Title>
-			<ModalCloseButton />
-		</ModalHeader>
-
-		<p v-if='body' :class='$style.body'>
-			{{ body }}
-		</p>
-
-		<footer :class='$style.footer'>
-			<Button
-				variant='default'
-				v-bind='cancelProps'
-				@click='handleCancel()'
-			>
-				{{ labels?.cancel ?? "Cancel" }}
-			</Button>
-			<Button
-				variant='filled'
-				v-bind='confirmProps'
-				:color="variant === 'danger' ? 'red' : void 0"
-				:loading
-				@click='hanleConfirm()'
-			>
-				{{ labels?.confirm ?? "Confirm" }}
-			</Button>
-		</footer>
-	</ModalRoot>
+	<ModalRoot v-model:open='opened' v-bind='rest' :close-on-click-outside size='sm'>
+		<ModalHeader>
+			<Title order='4'>
+				{{ title }}
+			</Title>
+			<ModalCloseButton />
+		</ModalHeader>
+
+		<p v-if='body' :class='$style.body'>
+			{{ body }}
+		</p>
+
+		<footer :class='$style.footer'>
+			<Button
+				variant='default'
+				v-bind='cancelProps'
+				@click='handleCancel()'
+			>
+				{{ labels?.cancel ?? "Cancel" }}
+			</Button>
+			<Button
+				variant='filled'
+				v-bind='confirmProps'
+				:color="variant === 'danger' ? 'red' : void 0"
+				:loading
+				@click='hanleConfirm()'
+			>
+				{{ labels?.confirm ?? "Confirm" }}
+			</Button>
+		</footer>
+	</ModalRoot>
 </template>
 
 <style module>

package/dist/runtime/modals/_confirm-modal/confirm-modal.vue.d.ts

@@ -1,5 +1,5 @@
+import type { MaybePromise } from '@nui/types';
 import type { ButtonProps, ModalRootProps } from '../../components/index.js';
-import type { MaybePromise } from '../../types/index.js';
 type ConfirmLabels = Record<'confirm' | 'cancel', string>;
 export interface ConfirmModalProps extends /* @vue-ignore */ ModalRootProps {
     /** Modal title */

package/dist/runtime/modals/modal-manager.d.ts

@@ -1,68 +1,51 @@
 import type { Component } from 'vue';
-/**
- * Reactive state of a single modal within {@link ModalManager}.
- */
+/** Reactive state of a single active modal. */
 export interface ModalState<Props extends object = object, Resolve = unknown, Reject = unknown> {
-    /** Unique modal identifier */
+    /** Unique modal identifier. */
     id: string;
-    /** Vue component rendered as the modal */
+    /** Vue component rendered as the modal. */
     component: Component;
-    /** Props passed when calling `show` or the opener function */
+    /** Props passed when opening the modal. */
     props: Props;
-    /** Current visibility state */
+    /** Current visibility state. */
     opened: boolean;
-    /** Resolves the promise created when the modal was opened */
+    /** Resolves the promise created when the modal was opened. */
     resolve: (value?: Resolve) => void;
-    /** Rejects the promise created when the modal was opened */
+    /** Rejects the promise created when the modal was opened. */
     reject: (reason?: Reject) => void;
 }
+/**
+ * Global modal manager.
+ *
+ * Maintains a component registry and a reactive map of active modals.
+ * Opening a modal returns a promise that resolves via `resolve` or rejects
+ * via `reject` / user dismissal.
+ *
+ * @example
+ * ```ts
+ * const open = $modals.create<MyProps, string>('my-modal', MyModal)
+ * const result = await open({ foo: 'bar' }) // result: string
+ * ```
+ */
 export declare class ModalManager {
     #private;
     /** Reactive map of active modals */
     readonly modals: import("vue").Reactive<Map<string, ModalState<object, unknown, unknown>>>;
     private constructor();
     static get instance(): ModalManager;
-    /**
-     * Registers a modal component and returns a typed function to open it.
-     */
-    create<TProps extends object = object, TResult = void>(
-    /** unique modal identifier */
-    id: string, 
-    /** Vue component for the modal */
-    component: Component): (props?: TProps) => Promise<TResult>;
-    /**
-     * Registers a lazy modal — the component is loaded on first open.
-     */
-    createLazy<TProps extends object = object, TResult = void>(
-    /** unique modal identifier */
-    id: string, 
-    /** dynamic import function (`() => import('./my-modal.vue')`) */
-    loader: () => Promise<{
+    /** Registers a modal component and returns a typed opener function. */
+    create<TProps extends object = object, TResult = void>(id: string, component: Component): (props?: TProps) => Promise<TResult>;
+    /** Registers a lazy modal. The component is loaded on first open. */
+    createLazy<TProps extends object = object, TResult = void>(id: string, loader: () => Promise<{
         default: Component;
     }>): (props?: Omit<TProps, 'modalId'>) => Promise<TResult>;
-    /**
-     * Opens a previously registered modal by its identifier.
-     */
+    /** Opens a previously registered modal by its identifier. */
     show<T = unknown>(id: string, props?: object): Promise<T>;
-    /**
-     * Closes the modal and resolves its promise with the given result.
-     *
-     * @param id     — modal identifier
-     * @param result — value the promise resolves with
-     */
+    /** Closes the modal and resolves its promise with the given result. */
     resolve(id: string, result?: any): void;
-    /**
-     * Closes the modal and rejects its promise with the given reason.
-     *
-     * @param id     — modal identifier
-     * @param reason — rejection reason
-     */
+    /** Closes the modal and rejects its promise with the given reason. */
     reject(id: string, reason?: any): void;
-    /**
-     * Returns the reactive state of a specific modal as `ComputedRef<ModalState>`.
-     *
-     * Used inside a modal component (via {@link useModal}).
-     */
+    /** Returns the reactive state of a specific modal. */
     state<Props extends object = object, Resolve = unknown, Reject = unknown>(id: string): ModalState<Props, Resolve, Reject>;
 }
 export declare const $modals: import("vue").Raw<ModalManager>;

package/dist/runtime/modals/modal-manager.js

@@ -3,9 +3,9 @@ const GLOBAL_KEY = "__nui_modal_manager__";
 export class ModalManager {
   /** Reactive map of active modals */
   modals = reactive(/* @__PURE__ */ new Map());
-  /** Eagerly registered components (id → Component) */
+  /** Eagerly registered components */
   #registered = /* @__PURE__ */ new Map();
-  /** Lazily registered loaders (id → loader) */
+  /** Lazily registered loaders */
   #lazy = /* @__PURE__ */ new Map();
   constructor() {
   }
@@ -15,49 +15,29 @@ export class ModalManager {
       globalThis[GLOBAL_KEY] = new ModalManager();
     return globalThis[GLOBAL_KEY];
   }
-  /**
-   * Registers a modal component and returns a typed function to open it.
-   */
+  /** Registers a modal component and returns a typed opener function. */
   create(id, component) {
     this.#registered.set(id, component);
     return (props) => this.#show(id, props ?? {});
   }
-  /**
-   * Registers a lazy modal — the component is loaded on first open.
-   */
+  /** Registers a lazy modal. The component is loaded on first open. */
   createLazy(id, loader) {
     this.#lazy.set(id, loader);
     return (props) => this.#show(id, props ?? {});
   }
-  /**
-   * Opens a previously registered modal by its identifier.
-   */
+  /** Opens a previously registered modal by its identifier. */
   async show(id, props = {}) {
     return this.#show(id, props);
   }
-  /**
-   * Closes the modal and resolves its promise with the given result.
-   *
-   * @param id     — modal identifier
-   * @param result — value the promise resolves with
-   */
+  /** Closes the modal and resolves its promise with the given result. */
   resolve(id, result) {
     this.#resolve(id, result);
   }
-  /**
-   * Closes the modal and rejects its promise with the given reason.
-   *
-   * @param id     — modal identifier
-   * @param reason — rejection reason
-   */
+  /** Closes the modal and rejects its promise with the given reason. */
   reject(id, reason) {
     this.#reject(id, reason);
   }
-  /**
-   * Returns the reactive state of a specific modal as `ComputedRef<ModalState>`.
-   *
-   * Used inside a modal component (via {@link useModal}).
-   */
+  /** Returns the reactive state of a specific modal. */
   state(id) {
     return this.modals.get(id);
   }

package/dist/runtime/modals/modals-provider.d.vue.ts

@@ -1,9 +1,3 @@
-import type { ModalManager } from './modal-manager.js';
-type __VLS_Props = {
-    manager?: ModalManager;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
-    manager: import("vue").Raw<ModalManager>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/modals/modals-provider.vue

@@ -1,22 +1,16 @@
 <script setup>
 import { $modals } from "./modal-manager";
-defineProps({
-  manager: { type: Object, required: false }
-});
-defineExpose({
-  manager: $modals
-});
 </script>
 
 <template>
-	<ClientOnly>
-		<div id='nui-modals-root'>
-			<component
-				:is='entry.component'
-				v-for='[id, entry] in $props.manager?.modals ?? $modals.modals'
-				:key='id'
-				v-bind='entry.props'
-			/>
-		</div>
-	</ClientOnly>
+	<ClientOnly>
+		<div id='nui-modals-root'>
+			<component
+				:is='entry.component'
+				v-for='[id, entry] in $modals.modals'
+				:key='id'
+				v-bind='entry.props'
+			/>
+		</div>
+	</ClientOnly>
 </template>