selective-ui 1.1.2 → 1.1.3

package/dist/selective-ui.esm.js

@@ -1,4 +1,4 @@
-/*! Selective UI v1.1.2 | MIT License */
+/*! Selective UI v1.1.3 | MIT License */
 /**
  * @class
  */
@@ -5151,6 +5151,9 @@ class ElementAdditionObserver {
 }
 
 class Selective {
+    constructor() {
+        this.bindedQueries = new Map();
+    }
     /**
      * Binds Selective UI to all <select> elements matching the query.
      * Merges provided options with defaults, schedules `on.load` callbacks,
@@ -5159,7 +5162,7 @@ class Selective {
      * @param {string} query - CSS selector for target <select> elements.
      * @param {object} options - Configuration overrides merged with defaults.
      */
-    static bind(query, options) {
+    bind(query, options) {
         const merged = Libs.mergeConfig(Libs.getDefaultConfig(), options);
         // Ensure hooks exist
         merged.on = merged.on ?? {};
@@ -5193,7 +5196,7 @@ class Selective {
      * @param {string} [query="*"] - CSS selector or "*" to search all bound instances.
      * @returns {SelectiveActionApi} - Aggregated actions; {isEmpty:true} if none found.
      */
-    static find(query = "*") {
+    find(query = "*") {
         const empty = { isEmpty: true };
         if (query === "*") {
             query = Libs.getBindedCommand().join(", ");
@@ -5228,7 +5231,7 @@ class Selective {
      * Starts observing the document for newly added <select> elements and applies
      * Selective bindings automatically when they match previously bound queries.
      */
-    static Observer() {
+    Observer() {
         this.EAObserver = new ElementAdditionObserver();
         this.EAObserver.onDetect((selectElement) => {
             this.bindedQueries.forEach((options, query) => {
@@ -5252,7 +5255,7 @@ class Selective {
      *
      * @param {null|string|HTMLSelectElement} target - Target to destroy.
      */
-    static destroy(target = null) {
+    destroy(target = null) {
         if (target === null) {
             this.destroyAll();
         }
@@ -5267,7 +5270,7 @@ class Selective {
      * Destroys all bound Selective instances and clears bindings/state.
      * Stops the ElementAdditionObserver.
      */
-    static destroyAll() {
+    destroyAll() {
         const bindedCommands = Libs.getBindedCommand();
         bindedCommands.forEach((query) => this.destroyByQuery(query));
         this.bindedQueries.clear();
@@ -5280,7 +5283,7 @@ class Selective {
      *
      * @param {string} query - CSS selector whose Selective instances should be destroyed.
      */
-    static destroyByQuery(query) {
+    destroyByQuery(query) {
         const selectElements = Libs.getElements(query);
         selectElements.forEach((element) => {
             if (element.tagName === "SELECT")
@@ -5298,7 +5301,7 @@ class Selective {
      *
      * @param {HTMLSelectElement} selectElement - The target <select> element to clean up.
      */
-    static destroyElement(selectElement) {
+    destroyElement(selectElement) {
         const bindMap = Libs.getBinderMap(selectElement);
         if (!bindMap)
             return;
@@ -5335,7 +5338,7 @@ class Selective {
      * @param {string} query - CSS selector to rebind.
      * @param {object} options - Configuration for the new binding.
      */
-    static rebind(query, options) {
+    rebind(query, options) {
         this.destroyByQuery(query);
         this.bind(query, options);
     }
@@ -5348,7 +5351,7 @@ class Selective {
      * @param {object} options - Configuration used for this instance.
      * @returns {boolean} - False if already bound; true if successfully applied.
      */
-    static applySelectBox(selectElement, options) {
+    applySelectBox(selectElement, options) {
         if (Libs.getBinderMap(selectElement) || Libs.getUnbinderMap(selectElement)) {
             return false;
         }
@@ -5379,7 +5382,7 @@ class Selective {
      * @param {*} action - The object containing the property.
      * @returns {PropertiesType} - The derived property type and name.
      */
-    static getProperties(actionName, action) {
+    getProperties(actionName, action) {
         const descriptor = Object.getOwnPropertyDescriptor(action, actionName);
         let type = "variable";
         if (descriptor?.get || (descriptor?.set && typeof action[actionName] !== "function")) {
@@ -5398,7 +5401,7 @@ class Selective {
      * @param {string} name - The property name to expose.
      * @param {HTMLElement[]} els - The list of bound elements to proxy.
      */
-    static buildGetSetAction(object, name, els) {
+    buildGetSetAction(object, name, els) {
         Object.defineProperty(object, name, {
             get() {
                 const binded = Libs.getBinderMap(els[0]);
@@ -5424,7 +5427,7 @@ class Selective {
      * @param {string} name - The function name to expose.
      * @param {HTMLElement[]} els - The list of bound elements to invoke against.
      */
-    static buildFuntionAction(object, name, els) {
+    buildFuntionAction(object, name, els) {
         object[name] = (...params) => {
             for (let index = 0; index < els.length; index++) {
                 const el = els[index];
@@ -5440,131 +5443,145 @@ class Selective {
         };
     }
 }
-Selective.bindedQueries = new Map();
 
 /**
- * Checks for a previously loaded global library instance by name.
- * initializes a loading placeholder on `window[name]` and returns false.
+ * Entry module for SelectiveUI.
  *
- * @param {string} LIB_NAME - The global namespace key to check on `window`.
- * @returns {boolean} - True if a loaded instance already exists; false otherwise.
+ * This file exposes the public API surface of the library:
+ * - version/name metadata
+ * - DOM binding helpers (bind/find/rebind/destroy)
+ * - effector factory for imperative effects
+ *
+ * Notes:
+ * - CSS imports below are *side-effect imports* used by bundlers (Vite/Webpack/Rollup)
+ *   to include component styles in the final bundle.
  */
-function checkDuplicate(LIB_NAME) {
-    if (typeof window === "undefined")
-        return false;
-    const existing = window[LIB_NAME];
-    if (existing) {
-        console.warn(`[${LIB_NAME}] Already loaded (v${existing.version}). ` +
-            `Using existing instance. Please remove duplicate <script> tags.`);
-        return true;
+/** Base/global styles for SelectiveUI. */
+const iVersion = "1.1.3";
+const iName = "SelectiveUI";
+if (typeof globalThis.GLOBAL_SEUI == "undefined") {
+    const SECLASS = new Selective();
+    globalThis.GLOBAL_SEUI = {
+        version: iVersion,
+        name: iName,
+        bind: SECLASS.bind.bind(SECLASS),
+        find: SECLASS.find.bind(SECLASS),
+        destroy: SECLASS.destroy.bind(SECLASS),
+        effector: Effector.bind(Effector),
+        rebind: SECLASS.rebind.bind(SECLASS)
+    };
+    let domInitialized = false;
+    function init() {
+        if (domInitialized)
+            return;
+        domInitialized = true;
+        document.addEventListener("mousedown", () => {
+            const sels = Libs.getBindedCommand();
+            if (sels.length > 0) {
+                const actionApi = SECLASS.find(sels.join(", "));
+                if (!actionApi.isEmpty)
+                    actionApi.close();
+            }
+        });
+        SECLASS.Observer();
     }
-    const base = existing ?? {};
-    window[LIB_NAME] = base;
-    return false;
+    if (typeof document !== "undefined") {
+        if (document.readyState === "loading") {
+            document.addEventListener("DOMContentLoaded", init);
+        }
+        else {
+            init();
+        }
+    }
+    console.log(`[${iName}] v${iVersion} loaded successfully`);
+}
+else {
+    console.warn(`[${globalThis.GLOBAL_SEUI.name}] Already loaded (v${globalThis.GLOBAL_SEUI.version}). ` +
+        `Using existing instance. Please remove duplicate <script> tags.`);
 }
 /**
- * Marks a global library namespace as fully loaded, sets version metadata,
- * merges its public API into `window[name]`, freezes the object to prevent
- * further mutation, and logs a success message.
+ * Current library version.
  *
- * @param {string} name - The global namespace key on `window`.
- * @param {string} version - Semantic version string of the library.
- * @param {SelectiveUIGlobal} api - Public API surface to expose under `window[name]`.
- * @returns {void}
+ * Declared as `const` literal type to enable strict typing and easy tree-shaking.
  */
-function markLoaded(name, version, api) {
-    if (typeof window === "undefined")
-        return;
-    const ns = (window[name] ?? {});
-    ns.version = version;
-    Object.assign(ns, api);
-    Object.freeze(ns);
-    window[name] = ns;
-    console.log(`[${name}] v${version} loaded successfully`);
-}
-
-const version = "1.1.2";
-const name = "SelectiveUI";
-const alreadyLoaded = checkDuplicate(name);
-function getGlobal() {
-    if (typeof window === "undefined")
-        return undefined;
-    return window[name];
-}
+const version = globalThis.GLOBAL_SEUI.version;
 /**
- * Enhances all <select> elements matching the query with Selective UI.
- * If a prior global instance is already loaded, proxies the call to it; otherwise uses local Selective.bind.
+ * Library name identifier.
+ *
+ * Can be used for debugging, logging, telemetry, or exposing global namespace metadata.
+ */
+const name = globalThis.GLOBAL_SEUI.name;
+/**
+ * Bind SelectiveUI behaviors to elements matched by a CSS selector.
+ *
+ * Typically used to initialize/select-enhance native `<select>` elements or custom containers.
+ *
+ * @param query - A CSS selector string used to find target elements in the DOM.
+ * @param options - Optional configuration used during initialization.
+ *
+ * @example
+ * bind(".my-select", { searchable: true });
  */
 function bind(query, options = {}) {
-    const global = getGlobal();
-    if (alreadyLoaded && global)
-        return global.bind(query, options);
-    Selective.bind(query, options);
+    globalThis.GLOBAL_SEUI.bind(query, options);
 }
 /**
- * Retrieves the dynamic action API for bound instances matching the query.
- * Proxies to an already-loaded global instance if present; otherwise uses local Selective.find.
+ * Find an existing SelectiveUI instance/actions API by selector.
+ *
+ * @param query - A CSS selector string previously used with `bind()` (or matching the same element).
+ * @returns An action API that allows controlling the instance (open/close/setValue/etc).
+ *
+ * @remarks
+ * The return type is casted to `SelectiveActionApi` for a stable public contract.
  */
 function find(query) {
-    const global = getGlobal();
-    if (alreadyLoaded && global)
-        return global.find(query);
-    return Selective.find(query);
+    return globalThis.GLOBAL_SEUI.find(query);
 }
 /**
- * Destroys Selective instances associated with the given query.
- * Proxies to a global loaded instance if available; otherwise uses local Selective.destroy.
+ * Destroy SelectiveUI instance(s) and release related resources.
+ *
+ * @param query - A CSS selector string identifying which instance(s) to destroy.
+ *               If `null`, destroys all instances managed by SelectiveUI.
+ *
+ * @example
+ * destroy(".my-select");
+ *
+ * @example
+ * // Destroy all instances
+ * destroy();
  */
 function destroy(query = null) {
-    const global = getGlobal();
-    if (alreadyLoaded && global)
-        return global.destroy(query);
-    Selective.destroy(query);
+    globalThis.GLOBAL_SEUI.destroy(query);
 }
 /**
- * Rebinds Selective for the given query by destroying existing instances and binding anew.
- * Proxies to a global loaded instance if available; otherwise uses local Selective.rebind.
+ * Rebind (reinitialize) SelectiveUI on the given selector.
+ *
+ * Useful when:
+ * - The DOM has changed dynamically
+ * - Options need to be reapplied
+ * - You want a clean re-init without manual destroy + bind
+ *
+ * @param query - A CSS selector string used to locate target elements.
+ * @param options - Optional configuration applied during re-initialization.
  */
 function rebind(query, options = {}) {
-    const global = getGlobal();
-    if (alreadyLoaded && global)
-        return global.rebind(query, options);
-    Selective.rebind(query, options);
+    globalThis.GLOBAL_SEUI.rebind(query, options);
 }
 /**
- * Returns an effector instance for a given element, enabling expand/collapse/resize animations.
- * Proxies to a global loaded instance if available; otherwise constructs a local Effector.
+ * Create an Effector instance for a given element.
+ *
+ * An effector provides imperative effect utilities bound to an element, such as animations,
+ * positioning, UI transitions, or event-driven effects (depending on implementation).
+ *
+ * @param element - A CSS selector string or a direct HTMLElement reference.
+ * @returns An `EffectorInterface` implementation bound to the given element.
+ *
+ * @example
+ * const fx = effector("#popup");
+ * fx.show();
  */
 function effector(element) {
-    const global = getGlobal();
-    if (alreadyLoaded && global)
-        return global.effector(element);
-    return Effector(element);
-}
-if (!alreadyLoaded) {
-    const api = { bind, find, destroy, rebind, effector, version };
-    markLoaded(name, version, api);
-    let domInitialized = false;
-    function init() {
-        if (domInitialized)
-            return;
-        domInitialized = true;
-        document.addEventListener("mousedown", () => {
-            const sels = Libs.getBindedCommand();
-            if (sels.length > 0) {
-                const actionApi = Selective.find(sels.join(", "));
-                if (!actionApi.isEmpty)
-                    actionApi.close();
-            }
-        });
-        Selective.Observer();
-    }
-    if (document.readyState === "loading") {
-        document.addEventListener("DOMContentLoaded", init);
-    }
-    else {
-        init();
-    }
+    return globalThis.GLOBAL_SEUI.effector(element);
 }
 
 export { bind, destroy, effector, find, name, rebind, version };