nuance-ui 0.1.58 → 0.1.59

package/dist/module.json

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

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

@@ -1,6 +1,6 @@
 import type { Component } from 'vue';
 /**
- * Reactive state of a single modal within {@link ModalManager}.
+ * Reactive state of a single modal within the modal manager.
  */
 export interface ModalState<Props extends object = object, Resolve = unknown, Reject = unknown> {
     /** Unique modal identifier */
@@ -16,11 +16,43 @@ 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 `hide`
+ * Opening a modal returns a `Promise` that resolves via `resolve`
  * or rejects via `reject` / user dismissal.
  *
  * @example
@@ -29,54 +61,13 @@ export interface ModalState<Props extends object = object, Resolve = unknown, Re
  * const result = await open({ foo: 'bar' }) // result: string
  * ```
  */
-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>;
+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 {};

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

@@ -1,112 +1,70 @@
 import { markRaw, reactive } from "vue";
-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);
-  }
-  // ── 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);
-      }
+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);
     }
-    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);
   }
+  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
+      });
+    }
+  });
+}
+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);
 }
-export const $modals = markRaw(ModalManager.instance);
+export const $modals = markRaw({
+  modals,
+  create,
+  createLazy,
+  show,
+  resolve,
+  reject,
+  state
+});

package/package.json

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