nuance-ui 0.1.59 → 0.1.60

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": "^4.0.0"
   },
-  "version": "0.1.59",
+  "version": "0.1.60",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -38,7 +38,6 @@ const module$1 = defineNuxtModule({
     nuxt.options.alias["@nui/helpers"] = resolve("./runtime/helpers");
     nuxt.options.alias["@nui/types"] = resolve("./runtime/types");
     nuxt.options.alias["@nui/modals"] = resolve("./runtime/modals");
-    nuxt.options.appConfig.nui = defu(nuxt.options.appConfig.nui || {}, defaultConfig);
     nuxt.options.postcss = nuxt.options.postcss || {};
     nuxt.options.postcss.plugins = nuxt.options.postcss.plugins || {};
     nuxt.options.postcss.plugins = defu(nuxt.options.postcss.plugins, {

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

@@ -1,6 +1,6 @@
 import type { Component } from 'vue';
 /**
- * Reactive state of a single modal within the modal manager.
+ * Reactive state of a single modal within {@link ModalManager}.
  */
 export interface ModalState<Props extends object = object, Resolve = unknown, Reject = unknown> {
     /** Unique modal identifier */
@@ -16,43 +16,11 @@ export interface ModalState<Props extends object = object, Resolve = unknown, Re
     /** Rejects the promise created when the modal was opened */
     reject: (reason?: Reject) => void;
 }
-declare function show<T = unknown>(id: string, props?: object): Promise<T>;
-/**
- * Registers a modal component and returns a typed function to open it.
- */
-declare function 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.
- */
-declare function createLazy<TProps extends object = object, TResult = void>(
-/** unique modal identifier */
-id: string, 
-/** dynamic import function (`() => import('./my-modal.vue')`) */
-loader: () => Promise<{
-    default: Component;
-}>): (props?: Omit<TProps, 'modalId'>) => Promise<TResult>;
-/**
- * Closes the modal and resolves its promise with the given result.
- */
-declare function resolve(id: string, result?: any): void;
-/**
- * Closes the modal and rejects its promise with the given reason.
- */
-declare function reject(id: string, reason?: any): void;
-/**
- * Returns the reactive state of a specific modal.
- * Used inside a modal component (via {@link useModal}).
- */
-declare function state<Props extends object = object, Resolve = unknown, Reject = unknown>(id: string): ModalState<Props, Resolve, Reject>;
 /**
  * Modal manager.
  *
  * Maintains a component registry and a reactive map of active modals.
- * Opening a modal returns a `Promise` that resolves via `resolve`
+ * Opening a modal returns a `Promise` that resolves via `hide`
  * or rejects via `reject` / user dismissal.
  *
  * @example
@@ -61,13 +29,53 @@ declare function state<Props extends object = object, Resolve = unknown, Reject
  * const result = await open({ foo: 'bar' }) // result: string
  * ```
  */
-export declare const $modals: import("vue").Raw<{
-    modals: import("vue").Reactive<Map<string, ModalState<object, unknown, unknown>>>;
-    create: typeof create;
-    createLazy: typeof createLazy;
-    show: typeof show;
-    resolve: typeof resolve;
-    reject: typeof reject;
-    state: typeof state;
-}>;
-export {};
+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<{
+        default: Component;
+    }>): (props?: Omit<TProps, 'modalId'>) => Promise<TResult>;
+    /**
+     * 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
+     */
+    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
+     */
+    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}).
+     */
+    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

@@ -1,70 +1,112 @@
 import { markRaw, reactive } from "vue";
-const modals = reactive(/* @__PURE__ */ new Map());
-const registered = /* @__PURE__ */ new Map();
-const lazy = /* @__PURE__ */ new Map();
-async function show(id, props = {}) {
-  if (!registered.has(id) && lazy.has(id)) {
-    const loader = lazy.get(id);
-    try {
-      const loaded = await loader();
-      registered.set(id, loaded.default);
-    } catch (err) {
-      return Promise.reject(err);
-    }
+export class ModalManager {
+  static #instance = null;
+  /** Reactive map of active modals */
+  modals = reactive(/* @__PURE__ */ new Map());
+  /** Eagerly registered components (id → Component) */
+  #registered = /* @__PURE__ */ new Map();
+  /** Lazily registered loaders (id → loader) */
+  #lazy = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  // ── Facade ──
+  static get instance() {
+    if (!this.#instance)
+      this.#instance = new ModalManager();
+    return this.#instance;
+  }
+  /**
+   * Registers a modal component and returns a typed function to open it.
+   */
+  create(id, component) {
+    ModalManager.instance.#registered.set(id, component);
+    return (props) => ModalManager.instance.#show(id, props ?? {});
+  }
+  /**
+   * Registers a lazy modal — the component is loaded on first open.
+   */
+  createLazy(id, loader) {
+    ModalManager.instance.#lazy.set(id, loader);
+    return (props) => ModalManager.instance.#show(id, props ?? {});
+  }
+  /**
+   * Opens a previously registered modal by its identifier.
+   */
+  async show(id, props = {}) {
+    return ModalManager.instance.#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
+   */
+  resolve(id, result) {
+    ModalManager.instance.#resolve(id, result);
+  }
+  /**
+   * Closes the modal and rejects its promise with the given reason.
+   *
+   * @param id     — modal identifier
+   * @param reason — rejection reason
+   */
+  reject(id, reason) {
+    ModalManager.instance.#reject(id, reason);
+  }
+  /**
+   * Returns the reactive state of a specific modal as `ComputedRef<ModalState>`.
+   *
+   * Used inside a modal component (via {@link useModal}).
+   */
+  state(id) {
+    return ModalManager.instance.modals.get(id);
   }
-  const component = registered.get(id);
-  if (!component)
-    return Promise.reject(new Error(`Modal "${id}" is not registered`));
-  const existing = modals.get(id);
-  return new Promise((resolve2, reject2) => {
-    if (existing) {
-      existing.props = props;
-      existing.opened = true;
-      existing.resolve = resolve2;
-      existing.reject = reject2;
-    } else {
-      modals.set(id, {
-        id,
-        component: markRaw(component),
-        props,
-        opened: true,
-        resolve: resolve2,
-        reject: reject2
-      });
+  // ── Private implementation ──
+  async #show(id, props = {}) {
+    if (!this.#registered.has(id) && this.#lazy.has(id)) {
+      const loader = this.#lazy.get(id);
+      try {
+        const loaded = await loader();
+        this.#registered.set(id, loaded.default);
+      } catch (err) {
+        return Promise.reject(err);
+      }
     }
-  });
-}
-function create(id, component) {
-  registered.set(id, component);
-  return (props) => show(id, props ?? {});
-}
-function createLazy(id, loader) {
-  lazy.set(id, loader);
-  return (props) => show(id, props ?? {});
-}
-function resolve(id, result) {
-  const modal = modals.get(id);
-  if (!modal)
-    return;
-  modal.opened = false;
-  modal.resolve?.(result);
-}
-function reject(id, reason) {
-  const modal = modals.get(id);
-  if (!modal)
-    return;
-  modal.opened = false;
-  modal.reject?.(reason);
-}
-function state(id) {
-  return modals.get(id);
+    const component = this.#registered.get(id);
+    if (!component)
+      return Promise.reject(new Error(`Modal "${id}" is not registered`));
+    const existing = this.modals.get(id);
+    return new Promise((resolve, reject) => {
+      if (existing) {
+        existing.props = props;
+        existing.opened = true;
+        existing.resolve = resolve;
+        existing.reject = reject;
+      } else {
+        this.modals.set(id, {
+          id,
+          component: markRaw(component),
+          props,
+          opened: true,
+          resolve,
+          reject
+        });
+      }
+    });
+  }
+  #resolve(id, result) {
+    const modal = this.modals.get(id);
+    if (!modal)
+      return;
+    modal.opened = false;
+    modal.resolve?.(result);
+  }
+  #reject(id, reason) {
+    const modal = this.modals.get(id);
+    if (!modal)
+      return;
+    modal.opened = false;
+    modal.reject?.(reason);
+  }
 }
-export const $modals = markRaw({
-  modals,
-  create,
-  createLazy,
-  show,
-  resolve,
-  reject,
-  state
-});
+export const $modals = markRaw(ModalManager.instance);

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

@@ -1,3 +1,9 @@
-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>;
+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 _default: typeof __VLS_export;
 export default _default;

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

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

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

@@ -1,3 +1,9 @@
-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>;
+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 _default: typeof __VLS_export;
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "nuance-ui",
-	"version": "0.1.59",
+	"version": "0.1.60",
 	"description": "A UI Library for Modern Web Apps, powered by Vue.",
 	"repository": {
 		"type": "git",