@studiometa/js-toolkit 2.4.7 → 2.6.0

package/Base/index.cjs

@@ -1,8 +1,6 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
@@ -17,10 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
@@ -34,11 +28,11 @@ __export(Base_exports, {
 });
 module.exports = __toCommonJS(Base_exports);
 var import_utils = require("./utils.cjs");
-var import_ChildrenManager = __toESM(require("./managers/ChildrenManager.cjs"), 1);
-var import_RefsManager = __toESM(require("./managers/RefsManager.cjs"), 1);
-var import_ServicesManager = __toESM(require("./managers/ServicesManager.cjs"), 1);
-var import_EventsManager = __toESM(require("./managers/EventsManager.cjs"), 1);
-var import_OptionsManager = __toESM(require("./managers/OptionsManager.cjs"), 1);
+var import_ChildrenManager = require("./managers/ChildrenManager.cjs");
+var import_RefsManager = require("./managers/RefsManager.cjs");
+var import_ServicesManager = require("./managers/ServicesManager.cjs");
+var import_EventsManager = require("./managers/EventsManager.cjs");
+var import_OptionsManager = require("./managers/OptionsManager.cjs");
 var import_utils2 = require("../utils/index.cjs");
 var id = 0;
 function createAndTestManagers(instance) {
@@ -46,27 +40,27 @@ function createAndTestManagers(instance) {
     {
       prop: "__options",
       constructorName: "OptionsManager",
-      constructor: import_OptionsManager.default
+      constructor: import_OptionsManager.OptionsManager
     },
     {
       prop: "__services",
       constructorName: "ServicesManager",
-      constructor: import_ServicesManager.default
+      constructor: import_ServicesManager.ServicesManager
     },
     {
       prop: "__events",
       constructorName: "EventsManager",
-      constructor: import_EventsManager.default
+      constructor: import_EventsManager.EventsManager
     },
     {
       prop: "__refs",
       constructorName: "RefsManager",
-      constructor: import_RefsManager.default
+      constructor: import_RefsManager.RefsManager
     },
     {
       prop: "__children",
       constructorName: "ChildrenManager",
-      constructor: import_ChildrenManager.default
+      constructor: import_ChildrenManager.ChildrenManager
     }
   ].forEach(({ prop, constructorName, constructor }) => {
     instance[prop] = new instance.__managers[constructorName](instance);
@@ -168,11 +162,11 @@ var Base = class extends EventTarget {
   }
   get __managers() {
     return {
-      ChildrenManager: import_ChildrenManager.default,
-      EventsManager: import_EventsManager.default,
-      OptionsManager: import_OptionsManager.default,
-      RefsManager: import_RefsManager.default,
-      ServicesManager: import_ServicesManager.default
+      ChildrenManager: import_ChildrenManager.ChildrenManager,
+      EventsManager: import_EventsManager.EventsManager,
+      OptionsManager: import_OptionsManager.OptionsManager,
+      RefsManager: import_RefsManager.RefsManager,
+      ServicesManager: import_ServicesManager.ServicesManager
     };
   }
   __callMethod(method, ...args) {

package/Base/index.d.ts

@@ -1,8 +1,8 @@
-import ChildrenManager from './managers/ChildrenManager.js';
-import RefsManager from './managers/RefsManager.js';
-import ServicesManager from './managers/ServicesManager.js';
-import EventsManager from './managers/EventsManager.js';
-import OptionsManager from './managers/OptionsManager.js';
+import { ChildrenManager } from './managers/ChildrenManager.js';
+import { RefsManager } from './managers/RefsManager.js';
+import { ServicesManager } from './managers/ServicesManager.js';
+import { EventsManager } from './managers/EventsManager.js';
+import { OptionsManager } from './managers/OptionsManager.js';
 export declare type BaseEl = HTMLElement & {
     __base__?: WeakMap<BaseConstructor, Base | 'terminated'>;
 };

package/Base/index.js

@@ -5,11 +5,11 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 import { getComponentElements, getEventTarget } from "./utils.js";
-import ChildrenManager from "./managers/ChildrenManager.js";
-import RefsManager from "./managers/RefsManager.js";
-import ServicesManager from "./managers/ServicesManager.js";
-import EventsManager from "./managers/EventsManager.js";
-import OptionsManager from "./managers/OptionsManager.js";
+import { ChildrenManager } from "./managers/ChildrenManager.js";
+import { RefsManager } from "./managers/RefsManager.js";
+import { ServicesManager } from "./managers/ServicesManager.js";
+import { EventsManager } from "./managers/EventsManager.js";
+import { OptionsManager } from "./managers/OptionsManager.js";
 import { noop, isDev, isFunction, isArray } from "../utils/index.js";
 let id = 0;
 function createAndTestManagers(instance) {

package/Base/managers/AbstractManager.cjs

@@ -21,10 +21,10 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 
-// packages/js-toolkit/Base/managers/AbstractManager.js
+// packages/js-toolkit/Base/managers/AbstractManager.ts
 var AbstractManager_exports = {};
 __export(AbstractManager_exports, {
-  default: () => AbstractManager
+  AbstractManager: () => AbstractManager
 });
 module.exports = __toCommonJS(AbstractManager_exports);
 var AbstractManager = class {

package/Base/managers/AbstractManager.d.ts

@@ -1,37 +1,30 @@
-/**
- * @typedef {import('../index.js').Base} Base
- * @typedef {import('../index.js').BaseConfig} BaseConfig
- * @typedef {import('./EventsManager.js').default} EventsManager
- */
+import type { Base } from '../index.js';
 /**
  * AbstractManager class.
  */
-export default class AbstractManager {
-    /**
-     * Class constructor.
-     *
-     * @param   {Base} base
-     */
-    constructor(base: Base);
+export declare class AbstractManager {
     /**
-     * @type {Base}
+     * Base instance.
      */
     __base: Base;
     /**
      * Get the base instance root element.
-     * @returns {HTMLElement}
      */
-    get __element(): HTMLElement;
+    get __element(): HTMLElement & {
+        __base__?: WeakMap<import("../index.js").BaseConstructor<Base<import("../index.js").BaseProps>>, Base<import("../index.js").BaseProps> | "terminated">;
+    };
     /**
      * Get the base instance config.
-     * @returns {BaseConfig}
      */
     get __config(): import("../index.js").BaseConfig;
     /**
      * Get the events manager.
-     * @returns {EventsManager}
      */
-    get __eventsManager(): import("./EventsManager.js").default;
+    get __eventsManager(): import("./EventsManager.js").EventsManager;
+    /**
+     * Class constructor.
+     */
+    constructor(base: Base);
     /**
      * Prevent a list of properties from being enumerable and writable.
      * @param   {string[]} properties
@@ -39,6 +32,3 @@ export default class AbstractManager {
      */
     __hideProperties(properties: string[]): void;
 }
-export type Base = import('../index.js').Base;
-export type BaseConfig = import('../index.js').BaseConfig;
-export type EventsManager = import('./EventsManager.js').default;

package/Base/managers/AbstractManager.js

@@ -36,5 +36,5 @@ class AbstractManager {
   }
 }
 export {
-  AbstractManager as default
+  AbstractManager
 };

package/Base/managers/ChildrenManager.cjs

@@ -1,8 +1,6 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
@@ -17,10 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
@@ -30,10 +24,10 @@ var __publicField = (obj, key, value) => {
 // packages/js-toolkit/Base/managers/ChildrenManager.ts
 var ChildrenManager_exports = {};
 __export(ChildrenManager_exports, {
-  default: () => ChildrenManager
+  ChildrenManager: () => ChildrenManager
 });
 module.exports = __toCommonJS(ChildrenManager_exports);
-var import_AbstractManager = __toESM(require("./AbstractManager.cjs"), 1);
+var import_AbstractManager = require("./AbstractManager.cjs");
 var import_utils = require("../utils.cjs");
 function __getChild(that, el, ComponentClass, name) {
   const asyncComponentPromise = that.__asyncComponentPromises.get(ComponentClass);
@@ -104,7 +98,7 @@ function __triggerHookForAll(that, hook) {
     });
   });
 }
-var ChildrenManager = class extends import_AbstractManager.default {
+var ChildrenManager = class extends import_AbstractManager.AbstractManager {
   constructor() {
     super(...arguments);
     __publicField(this, "__asyncComponentPromises", /* @__PURE__ */ new WeakMap());

package/Base/managers/ChildrenManager.d.ts

@@ -1,9 +1,9 @@
 import type { BaseConstructor, BaseAsyncConstructor } from '../index.js';
-import AbstractManager from './AbstractManager.js';
+import { AbstractManager } from './AbstractManager.js';
 /**
  * Children manager.
  */
-export default class ChildrenManager extends AbstractManager {
+export declare class ChildrenManager extends AbstractManager {
     /**
      * Store async component promises to avoid calling them multiple times and
      * waiting for them when they are already resolved.

package/Base/managers/ChildrenManager.js

@@ -4,7 +4,7 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-import AbstractManager from "./AbstractManager.js";
+import { AbstractManager } from "./AbstractManager.js";
 import { getComponentElements } from "../utils.js";
 function __getChild(that, el, ComponentClass, name) {
   const asyncComponentPromise = that.__asyncComponentPromises.get(ComponentClass);
@@ -99,5 +99,5 @@ class ChildrenManager extends AbstractManager {
   }
 }
 export {
-  ChildrenManager as default
+  ChildrenManager
 };

package/Base/managers/EventsManager.cjs

@@ -30,7 +30,7 @@ var __publicField = (obj, key, value) => {
 // packages/js-toolkit/Base/managers/EventsManager.ts
 var EventsManager_exports = {};
 __export(EventsManager_exports, {
-  default: () => EventsManager,
+  EventsManager: () => EventsManager,
   normalizeEventName: () => normalizeEventName,
   normalizeName: () => normalizeName
 });
@@ -38,22 +38,30 @@ module.exports = __toCommonJS(EventsManager_exports);
 var import_getAllProperties = __toESM(require("../../utils/object/getAllProperties.cjs"), 1);
 var import_utils = require("../../utils/index.cjs");
 var import_utils2 = require("../utils.cjs");
-var import_AbstractManager = __toESM(require("./AbstractManager.cjs"), 1);
+var import_AbstractManager = require("./AbstractManager.cjs");
 var import_RefsManager = require("./RefsManager.cjs");
 var names = /* @__PURE__ */ new Map();
+var normalizeRegex1 = /[A-Z]([A-Z].*)/g;
+var normalizeRegex2 = /[^a-zA-Z\d\s:]/g;
+var normalizeRegex3 = /(^\w|\s+\w)/g;
 function normalizeName(name) {
   if (!names.has(name)) {
     names.set(
       name,
-      name.replace(/[A-Z]([A-Z].*)/g, (c) => c.toLowerCase()).replace(/[^a-zA-Z\d\s:]/g, " ").replace(/(^\w|\s+\w)/g, (c) => c.trim().toUpperCase()).trim()
+      name.replace(normalizeRegex1, (c) => c.toLowerCase()).replace(normalizeRegex2, " ").replace(normalizeRegex3, (c) => c.trim().toUpperCase()).trim()
     );
   }
   return names.get(name);
 }
 var eventNames = /* @__PURE__ */ new Map();
+var normalizeEventRegex1 = /[A-Z]/g;
+var normalizeEventRegex2 = /^-/;
 function normalizeEventName(name) {
   if (!eventNames.has(name)) {
-    eventNames.set(name, name.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`).replace(/^-/, ""));
+    eventNames.set(
+      name,
+      name.replace(normalizeEventRegex1, (c) => `-${c.toLowerCase()}`).replace(normalizeEventRegex2, "")
+    );
   }
   return eventNames.get(name);
 }
@@ -100,16 +108,32 @@ function manageChild(that, name, instance, mode = "add") {
     instance[action](event, that.__childrenHandler);
   });
 }
+var isDocumentRegex = /^onDocument[A-Z][a-z]+/;
+var isWindowRegex = /^onWindow[A-Z][a-z]+/;
+var methodIsDocument = (method) => isDocumentRegex.test(method);
+var methodIsWindow = (method) => isWindowRegex.test(method);
+var methodIsGlobal = (method) => methodIsWindow(method) || methodIsDocument(method);
+var getGlobalEventTarget = (method) => methodIsDocument(method) ? document : window;
 function manageRootElement(that, mode = "add") {
   const modeMethod = `${mode}EventListener`;
   const methods = getEventMethodsByName(that);
   const { __base: base, __config: config } = that;
-  methods.map((method) => getEventNameByMethod(method)).filter((event) => (0, import_utils2.eventIsDefinedInConfig)(event, config) || (0, import_utils2.eventIsNative)(event, base.$el)).forEach((event) => {
-    const target = (0, import_utils2.getEventTarget)(base, event, config);
-    target[modeMethod](event, that.__rootElementHandler);
+  methods.forEach((method) => {
+    let event = getEventNameByMethod(method);
+    if ((0, import_utils2.eventIsDefinedInConfig)(event, config) || (0, import_utils2.eventIsNative)(event, base.$el)) {
+      const target = (0, import_utils2.getEventTarget)(base, event, config);
+      target[modeMethod](event, that.__rootElementHandler);
+    } else if (methodIsGlobal(method)) {
+      event = getEventNameByMethod(method, methodIsDocument(method) ? "document" : "window");
+      const target = getGlobalEventTarget(method);
+      target[modeMethod](
+        event,
+        methodIsDocument(method) ? that.__documentHandler : that.__windowHandler
+      );
+    }
   });
 }
-var EventsManager = class extends import_AbstractManager.default {
+var EventsManager = class extends import_AbstractManager.AbstractManager {
   constructor(base) {
     super(base);
     __publicField(this, "__methodsCache", /* @__PURE__ */ new Map());
@@ -124,6 +148,20 @@ var EventsManager = class extends import_AbstractManager.default {
         }
       }
     });
+    __publicField(this, "__documentHandler", {
+      handleEvent: (event) => {
+        const normalizedEventName = normalizeName(event.type);
+        const method = `onDocument${normalizedEventName}`;
+        this.__base[method](event);
+      }
+    });
+    __publicField(this, "__windowHandler", {
+      handleEvent: (event) => {
+        const normalizedEventName = normalizeName(event.type);
+        const method = `onWindow${normalizedEventName}`;
+        this.__base[method](event);
+      }
+    });
     __publicField(this, "__refsHandler", {
       handleEvent: (event) => {
         const ref = event.currentTarget;
@@ -159,7 +197,9 @@ var EventsManager = class extends import_AbstractManager.default {
       "__methodsCache",
       "__rootElementHandler",
       "__refsHandler",
-      "__childrenHandler"
+      "__childrenHandler",
+      "__documentHandler",
+      "__windowHandler"
     ]);
   }
   bindRef(name, elements) {

package/Base/managers/EventsManager.d.ts

@@ -1,5 +1,5 @@
 import type { Base } from '../index.js';
-import AbstractManager from './AbstractManager.js';
+import { AbstractManager } from './AbstractManager.js';
 /**
  * Normalize the given name to PascalCase, such as:
  *
@@ -33,12 +33,36 @@ export declare function normalizeEventName(name: string): string;
  * @todo Prevent binding of `onChildOrRefEvent` to the root element
  * @todo Use event delegation?
  */
-export default class EventsManager extends AbstractManager {
+export declare class EventsManager extends AbstractManager {
     __methodsCache: Map<string, string[]>;
     /**
      * Event listener object for the root element.
      */
     __rootElementHandler: EventListenerObject;
+    /**
+     * Event listener object for the root element.
+     *
+     * @type {EventListenerObject}
+     */
+    __documentHandler: {
+        /**
+         * @param   {Event|CustomEvent} event
+         * @returns {void}
+         */
+        handleEvent: (event: any) => void;
+    };
+    /**
+     * Event listener object for the root element.
+     *
+     * @type {EventListenerObject}
+     */
+    __windowHandler: {
+        /**
+         * @param   {Event|CustomEvent} event
+         * @returns {void}
+         */
+        handleEvent: (event: any) => void;
+    };
     /**
      * Event listener object for the refs.
      */

package/Base/managers/EventsManager.js

@@ -7,22 +7,30 @@ var __publicField = (obj, key, value) => {
 import getAllProperties from "../../utils/object/getAllProperties.js";
 import { isArray } from "../../utils/index.js";
 import { getEventTarget, eventIsNative, eventIsDefinedInConfig } from "../utils.js";
-import AbstractManager from "./AbstractManager.js";
+import { AbstractManager } from "./AbstractManager.js";
 import { normalizeRefName } from "./RefsManager.js";
 const names = /* @__PURE__ */ new Map();
+const normalizeRegex1 = /[A-Z]([A-Z].*)/g;
+const normalizeRegex2 = /[^a-zA-Z\d\s:]/g;
+const normalizeRegex3 = /(^\w|\s+\w)/g;
 function normalizeName(name) {
   if (!names.has(name)) {
     names.set(
       name,
-      name.replace(/[A-Z]([A-Z].*)/g, (c) => c.toLowerCase()).replace(/[^a-zA-Z\d\s:]/g, " ").replace(/(^\w|\s+\w)/g, (c) => c.trim().toUpperCase()).trim()
+      name.replace(normalizeRegex1, (c) => c.toLowerCase()).replace(normalizeRegex2, " ").replace(normalizeRegex3, (c) => c.trim().toUpperCase()).trim()
     );
   }
   return names.get(name);
 }
 const eventNames = /* @__PURE__ */ new Map();
+const normalizeEventRegex1 = /[A-Z]/g;
+const normalizeEventRegex2 = /^-/;
 function normalizeEventName(name) {
   if (!eventNames.has(name)) {
-    eventNames.set(name, name.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`).replace(/^-/, ""));
+    eventNames.set(
+      name,
+      name.replace(normalizeEventRegex1, (c) => `-${c.toLowerCase()}`).replace(normalizeEventRegex2, "")
+    );
   }
   return eventNames.get(name);
 }
@@ -69,13 +77,29 @@ function manageChild(that, name, instance, mode = "add") {
     instance[action](event, that.__childrenHandler);
   });
 }
+const isDocumentRegex = /^onDocument[A-Z][a-z]+/;
+const isWindowRegex = /^onWindow[A-Z][a-z]+/;
+const methodIsDocument = (method) => isDocumentRegex.test(method);
+const methodIsWindow = (method) => isWindowRegex.test(method);
+const methodIsGlobal = (method) => methodIsWindow(method) || methodIsDocument(method);
+const getGlobalEventTarget = (method) => methodIsDocument(method) ? document : window;
 function manageRootElement(that, mode = "add") {
   const modeMethod = `${mode}EventListener`;
   const methods = getEventMethodsByName(that);
   const { __base: base, __config: config } = that;
-  methods.map((method) => getEventNameByMethod(method)).filter((event) => eventIsDefinedInConfig(event, config) || eventIsNative(event, base.$el)).forEach((event) => {
-    const target = getEventTarget(base, event, config);
-    target[modeMethod](event, that.__rootElementHandler);
+  methods.forEach((method) => {
+    let event = getEventNameByMethod(method);
+    if (eventIsDefinedInConfig(event, config) || eventIsNative(event, base.$el)) {
+      const target = getEventTarget(base, event, config);
+      target[modeMethod](event, that.__rootElementHandler);
+    } else if (methodIsGlobal(method)) {
+      event = getEventNameByMethod(method, methodIsDocument(method) ? "document" : "window");
+      const target = getGlobalEventTarget(method);
+      target[modeMethod](
+        event,
+        methodIsDocument(method) ? that.__documentHandler : that.__windowHandler
+      );
+    }
   });
 }
 class EventsManager extends AbstractManager {
@@ -93,6 +117,20 @@ class EventsManager extends AbstractManager {
         }
       }
     });
+    __publicField(this, "__documentHandler", {
+      handleEvent: (event) => {
+        const normalizedEventName = normalizeName(event.type);
+        const method = `onDocument${normalizedEventName}`;
+        this.__base[method](event);
+      }
+    });
+    __publicField(this, "__windowHandler", {
+      handleEvent: (event) => {
+        const normalizedEventName = normalizeName(event.type);
+        const method = `onWindow${normalizedEventName}`;
+        this.__base[method](event);
+      }
+    });
     __publicField(this, "__refsHandler", {
       handleEvent: (event) => {
         const ref = event.currentTarget;
@@ -128,7 +166,9 @@ class EventsManager extends AbstractManager {
       "__methodsCache",
       "__rootElementHandler",
       "__refsHandler",
-      "__childrenHandler"
+      "__childrenHandler",
+      "__documentHandler",
+      "__windowHandler"
     ]);
   }
   bindRef(name, elements) {
@@ -151,7 +191,7 @@ class EventsManager extends AbstractManager {
   }
 }
 export {
-  EventsManager as default,
+  EventsManager,
   normalizeEventName,
   normalizeName
 };

package/Base/managers/OptionsManager.cjs

@@ -27,15 +27,15 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 
-// packages/js-toolkit/Base/managers/OptionsManager.js
+// packages/js-toolkit/Base/managers/OptionsManager.ts
 var OptionsManager_exports = {};
 __export(OptionsManager_exports, {
-  __getPropertyName: () => __getPropertyName,
-  default: () => OptionsManager
+  OptionsManager: () => OptionsManager,
+  __getPropertyName: () => __getPropertyName
 });
 module.exports = __toCommonJS(OptionsManager_exports);
 var import_deepmerge = __toESM(require("deepmerge"), 1);
-var import_AbstractManager = __toESM(require("./AbstractManager.cjs"), 1);
+var import_AbstractManager = require("./AbstractManager.cjs");
 var import_utils = require("../../utils/index.cjs");
 var types = /* @__PURE__ */ new Set([String, Number, Boolean, Array, Object]);
 var __defaultValues = {
@@ -75,16 +75,14 @@ function __register(that, name, config) {
     return;
   }
   Object.defineProperty(that, name, {
-    get: () => {
-      return that.get(name, config);
-    },
+    get: () => that.get(name, config),
     set: (value) => {
       that.set(name, value, config);
     },
     enumerable: true
   });
 }
-var OptionsManager = class extends import_AbstractManager.default {
+var OptionsManager = class extends import_AbstractManager.AbstractManager {
   constructor(base) {
     var _a, _b;
     super(base);