@studiometa/js-toolkit 2.0.0-beta.9 → 2.0.0

package/Base/managers/OptionsManager.js

@@ -1,28 +1,26 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import deepmerge from 'deepmerge';
-import isObject from '../../utils/object/isObject.js';
-export default class OptionsManager {
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import deepmerge from "deepmerge";
+import isObject from "../../utils/object/isObject.js";
+const _OptionsManager = class {
   constructor(element, schema, baseConfig) {
-    var _baseConfig$debug, _baseConfig$log;
-
-    _defineProperty(this, "__element", void 0);
-
-    _defineProperty(this, "__values", {});
-
-    _defineProperty(this, "__defaultValues", {
-      String: '',
+    __publicField(this, "__element");
+    __publicField(this, "__values", {});
+    __publicField(this, "__defaultValues", {
+      String: "",
       Number: 0,
       Boolean: false,
       Array: () => [],
       Object: () => ({})
     });
-
-    _defineProperty(this, "name", 'Base');
-
-    _defineProperty(this, "debug", false);
-
-    _defineProperty(this, "log", false);
-
+    __publicField(this, "name", "Base");
+    __publicField(this, "debug", false);
+    __publicField(this, "log", false);
+    var _a, _b;
     Object.defineProperties(this, {
       __element: {
         enumerable: false,
@@ -43,138 +41,109 @@ export default class OptionsManager {
     this.name = baseConfig.name;
     schema.debug = {
       type: Boolean,
-      default: (_baseConfig$debug = baseConfig.debug) !== null && _baseConfig$debug !== void 0 ? _baseConfig$debug : false
+      default: (_a = baseConfig.debug) != null ? _a : false
     };
     schema.log = {
       type: Boolean,
-      default: (_baseConfig$log = baseConfig.log) !== null && _baseConfig$log !== void 0 ? _baseConfig$log : false
+      default: (_b = baseConfig.log) != null ? _b : false
     };
-    Object.entries(schema).forEach(_ref => {
-      var [name, config] = _ref;
-
+    Object.entries(schema).forEach(([name, config]) => {
       this.__register(name, config);
     });
-    return this;
   }
-
   __register(name, config) {
-    var hasDefaultValue = !OptionsManager.types.includes(config);
-    var type = hasDefaultValue ? config.type : config;
-
-    if (!OptionsManager.types.includes(type)) {
-      throw new Error("The \"".concat(name, "\" option has an invalid type. The allowed types are: String, Number, Boolean, Array and Object."));
+    const isObjectConfig = typeof config === "object";
+    const hasDefaultValue = !_OptionsManager.types.includes(config);
+    const type = isObjectConfig ? config.type : config;
+    if (!_OptionsManager.types.includes(type)) {
+      throw new Error(`The "${name}" option has an invalid type. The allowed types are: String, Number, Boolean, Array and Object.`);
     }
-
-    var defaultValue = hasDefaultValue ? config.default : this.__defaultValues[type.name];
-
-    if ((type === Array || type === Object) && typeof defaultValue !== 'function') {
-      throw new Error("The default value for options of type \"".concat(type.name, "\" must be returned by a function."));
+    const defaultValue = hasDefaultValue ? config.default : this.__defaultValues[type.name];
+    if ((type === Array || type === Object) && typeof defaultValue !== "function") {
+      throw new Error(`The default value for options of type "${type.name}" must be returned by a function.`);
     }
-
     Object.defineProperty(this, name, {
       get: () => {
-        return this.get(name, type, defaultValue);
+        return this.get(name, type, defaultValue, isObjectConfig ? config.merge : void 0);
       },
-      set: value => {
+      set: (value) => {
         this.set(name, type, value, defaultValue);
       },
       enumerable: true
     });
   }
-
-  get(name, type, defaultValue) {
-    var propertyName = OptionsManager.__getPropertyName(name);
-
-    var hasProperty = this.__hasProperty(propertyName);
-
+  get(name, type, defaultValue, merge) {
+    const propertyName = _OptionsManager.__getPropertyName(name);
+    const hasProperty = this.__hasProperty(propertyName);
     if (type === Boolean) {
       if (defaultValue) {
-        var negatedPropertyName = OptionsManager.__getPropertyName(name, 'No');
-
-        var hasNegatedProperty = this.__hasProperty(negatedPropertyName);
-
+        const negatedPropertyName = _OptionsManager.__getPropertyName(name, "No");
+        const hasNegatedProperty = this.__hasProperty(negatedPropertyName);
         return !hasNegatedProperty;
       }
-
       return hasProperty || defaultValue;
     }
-
-    var value = this.__element.dataset[propertyName];
-
+    const value = this.__element.dataset[propertyName];
     if (type === Number) {
       return hasProperty ? Number(value) : defaultValue;
     }
-
     if (type === Array || type === Object) {
-      var val = deepmerge(defaultValue(), hasProperty ? JSON.parse(value) : this.__defaultValues[type.name]());
-
       if (!this.__values[name]) {
+        let val = hasProperty ? JSON.parse(value) : defaultValue();
+        if (typeof merge !== "undefined") {
+          val = typeof merge === "boolean" ? deepmerge(defaultValue(), val) : deepmerge(defaultValue(), val, merge);
+        }
         this.__values[name] = val;
       }
-
       return this.__values[name];
     }
-
     return hasProperty ? value : defaultValue;
   }
-
   set(name, type, value, defaultValue) {
-    var propertyName = OptionsManager.__getPropertyName(name);
-
+    const propertyName = _OptionsManager.__getPropertyName(name);
     if (value.constructor.name !== type.name) {
-      var val = Array.isArray(value) || isObject(value) ? JSON.stringify(value) : value;
-      throw new TypeError("The \"".concat(val, "\" value for the \"").concat(name, "\" option must be of type \"").concat(type.name, "\""));
+      const val = Array.isArray(value) || isObject(value) ? JSON.stringify(value) : value;
+      throw new TypeError(`The "${val}" value for the "${name}" option must be of type "${type.name}"`);
     }
-
     switch (type) {
       case Boolean:
         if (defaultValue) {
-          var negatedPropertyName = OptionsManager.__getPropertyName(name, 'No');
-
+          const negatedPropertyName = _OptionsManager.__getPropertyName(name, "No");
           if (value) {
             delete this.__element.dataset[negatedPropertyName];
           } else {
-            this.__element.dataset[negatedPropertyName] = '';
+            this.__element.dataset[negatedPropertyName] = "";
           }
         } else if (value) {
-          this.__element.dataset[propertyName] = '';
+          this.__element.dataset[propertyName] = "";
         } else {
           delete this.__element.dataset[propertyName];
         }
-
         break;
-
       case Array:
       case Object:
         this.__values[name] = value;
         break;
-
       default:
         this.__element.dataset[propertyName] = value;
     }
   }
-
   __hasProperty(prop) {
-    return typeof this.__element.dataset[prop] !== 'undefined';
+    return typeof this.__element.dataset[prop] !== "undefined";
   }
-
-  static __getPropertyName(name) {
-    var prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-    var key = name + prefix;
-
-    if (OptionsManager.__propertyNameCache.has(key)) {
-      return OptionsManager.__propertyNameCache.get(key);
+  static __getPropertyName(name, prefix = "") {
+    const key = name + prefix;
+    if (_OptionsManager.__propertyNameCache.has(key)) {
+      return _OptionsManager.__propertyNameCache.get(key);
     }
-
-    var propertyName = "option".concat(prefix).concat(name.replace(/^\w/, c => c.toUpperCase()));
-
-    OptionsManager.__propertyNameCache.set(key, propertyName);
-
+    const propertyName = `option${prefix}${name.replace(/^\w/, (c) => c.toUpperCase())}`;
+    _OptionsManager.__propertyNameCache.set(key, propertyName);
     return propertyName;
   }
-
-}
-
-_defineProperty(OptionsManager, "types", [String, Number, Boolean, Array, Object]);
-
-_defineProperty(OptionsManager, "__propertyNameCache", new Map());
+};
+let OptionsManager = _OptionsManager;
+__publicField(OptionsManager, "types", [String, Number, Boolean, Array, Object]);
+__publicField(OptionsManager, "__propertyNameCache", /* @__PURE__ */ new Map());
+export {
+  OptionsManager as default
+};

package/Base/managers/RefsManager.cjs

@@ -0,0 +1,99 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// packages/js-toolkit/Base/managers/RefsManager.js
+var RefsManager_exports = {};
+__export(RefsManager_exports, {
+  default: () => RefsManager
+});
+module.exports = __toCommonJS(RefsManager_exports);
+var RefsManager = class {
+  constructor(base, element, refs, eventsManager) {
+    __publicField(this, "__element");
+    __publicField(this, "__refs");
+    __publicField(this, "__base");
+    __publicField(this, "__eventsManager");
+    Object.defineProperties(this, {
+      __element: {
+        enumerable: false,
+        writable: false,
+        value: element
+      },
+      __refs: {
+        enumerable: false,
+        writable: false,
+        value: refs
+      },
+      __base: {
+        enumerable: false,
+        writable: false,
+        value: base
+      },
+      __eventsManager: {
+        enumerable: false,
+        writable: false,
+        value: eventsManager
+      }
+    });
+  }
+  registerAll() {
+    this.__refs.forEach((refName) => this.__register(refName));
+  }
+  unregisterAll() {
+    this.__refs.forEach((refName) => this.__unregister(refName));
+  }
+  __register(refName) {
+    const isMultiple = refName.endsWith("[]");
+    const propName = RefsManager.normalizeRefName(refName);
+    const refs = Array.from(this.__element.querySelectorAll(`[data-ref="${refName}"]`)).filter((ref) => this.__filterRefsBelongingToInstance(ref));
+    if (!isMultiple && refs.length > 1) {
+      console.warn(`[${this.__base.$options.name}]`, `The "${refName}" ref has been found multiple times.`, "Did you forgot to add the `[]` suffix to its name?");
+    }
+    if (!isMultiple && refs.length <= 1 && refs[0] === void 0) {
+      console.warn(`[${this.__base.$options.name}]`, `The "${refName}" ref is missing.`, `Is there an \`[data-ref="${refName}"]\` element in the component's scope?`);
+      return;
+    }
+    this.__eventsManager.bindRef(refName, refs);
+    Object.defineProperty(this, propName, {
+      value: isMultiple || refs.length > 1 ? refs : refs[0],
+      enumerable: true,
+      configurable: true
+    });
+  }
+  __unregister(refName) {
+    const propName = RefsManager.normalizeRefName(refName);
+    const refs = Array.isArray(this[propName]) ? this[propName] : [this[propName]];
+    this.__eventsManager.unbindRef(refName, refs);
+  }
+  static normalizeRefName(name) {
+    return name.endsWith("[]") ? name.replace(/\[\]$/, "") : name;
+  }
+  __filterRefsBelongingToInstance(ref) {
+    let ancestor = ref.parentElement;
+    while (ancestor && ancestor.dataset.component === void 0) {
+      ancestor = ancestor.parentElement;
+    }
+    return ancestor === null || ancestor === this.__element;
+  }
+};
+if (module.exports.default) module.exports = module.exports.default;

package/Base/managers/RefsManager.d.ts

@@ -12,7 +12,7 @@ export default class RefsManager {
      * Normalize the name of ref.
      *
      * @param {string} name The original name.
-     * @return {string}     The normalized name.
+     * @returns {string}     The normalized name.
      */
     static normalizeRefName(name: string): string;
     /**
@@ -50,13 +50,13 @@ export default class RefsManager {
     /**
      * Register all refs.
      *
-     * @return {void}
+     * @returns {void}
      */
     registerAll(): void;
     /**
      * Unregister all refs.
      *
-     * @return {void}
+     * @returns {void}
      */
     unregisterAll(): void;
     /**
@@ -77,7 +77,7 @@ export default class RefsManager {
      * Filter refs belonging to the related Base instance.
      *
      * @param {HTMLElement} ref The ref to test.
-     * @return {boolean}
+     * @returns {boolean}
      * @private
      */
     private __filterRefsBelongingToInstance;

package/Base/managers/RefsManager.js

@@ -1,14 +1,15 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-export default class RefsManager {
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class RefsManager {
   constructor(base, element, refs, eventsManager) {
-    _defineProperty(this, "__element", void 0);
-
-    _defineProperty(this, "__refs", void 0);
-
-    _defineProperty(this, "__base", void 0);
-
-    _defineProperty(this, "__eventsManager", void 0);
-
+    __publicField(this, "__element");
+    __publicField(this, "__refs");
+    __publicField(this, "__base");
+    __publicField(this, "__eventsManager");
     Object.defineProperties(this, {
       __element: {
         enumerable: false,
@@ -32,57 +33,46 @@ export default class RefsManager {
       }
     });
   }
-
   registerAll() {
-    this.__refs.forEach(refName => this.__register(refName));
+    this.__refs.forEach((refName) => this.__register(refName));
   }
-
   unregisterAll() {
-    this.__refs.forEach(refName => this.__unregister(refName));
+    this.__refs.forEach((refName) => this.__unregister(refName));
   }
-
   __register(refName) {
-    var isMultiple = refName.endsWith('[]');
-    var propName = RefsManager.normalizeRefName(refName);
-    var refs = Array.from(this.__element.querySelectorAll("[data-ref=\"".concat(refName, "\"]"))).filter(ref => this.__filterRefsBelongingToInstance(ref));
-
+    const isMultiple = refName.endsWith("[]");
+    const propName = RefsManager.normalizeRefName(refName);
+    const refs = Array.from(this.__element.querySelectorAll(`[data-ref="${refName}"]`)).filter((ref) => this.__filterRefsBelongingToInstance(ref));
     if (!isMultiple && refs.length > 1) {
-      console.warn("[".concat(this.__base.$options.name, "]"), "The \"".concat(refName, "\" ref has been found multiple times."), 'Did you forgot to add the `[]` suffix to its name?');
+      console.warn(`[${this.__base.$options.name}]`, `The "${refName}" ref has been found multiple times.`, "Did you forgot to add the `[]` suffix to its name?");
     }
-
-    if (!isMultiple && refs.length <= 1 && refs[0] === undefined) {
-      console.warn("[".concat(this.__base.$options.name, "]"), "The \"".concat(refName, "\" ref is missing."), "Is there an `[data-ref=\"".concat(refName, "\"]` element in the component's scope?"));
+    if (!isMultiple && refs.length <= 1 && refs[0] === void 0) {
+      console.warn(`[${this.__base.$options.name}]`, `The "${refName}" ref is missing.`, `Is there an \`[data-ref="${refName}"]\` element in the component's scope?`);
       return;
     }
-
     this.__eventsManager.bindRef(refName, refs);
-
     Object.defineProperty(this, propName, {
       value: isMultiple || refs.length > 1 ? refs : refs[0],
       enumerable: true,
       configurable: true
     });
   }
-
   __unregister(refName) {
-    var propName = RefsManager.normalizeRefName(refName);
-    var refs = Array.isArray(this[propName]) ? this[propName] : [this[propName]];
-
+    const propName = RefsManager.normalizeRefName(refName);
+    const refs = Array.isArray(this[propName]) ? this[propName] : [this[propName]];
     this.__eventsManager.unbindRef(refName, refs);
   }
-
   static normalizeRefName(name) {
-    return name.endsWith('[]') ? name.replace(/\[\]$/, '') : name;
+    return name.endsWith("[]") ? name.replace(/\[\]$/, "") : name;
   }
-
   __filterRefsBelongingToInstance(ref) {
-    var ancestor = ref.parentElement;
-
-    while (ancestor && ancestor.dataset.component === undefined) {
+    let ancestor = ref.parentElement;
+    while (ancestor && ancestor.dataset.component === void 0) {
       ancestor = ancestor.parentElement;
     }
-
     return ancestor === null || ancestor === this.__element;
   }
-
-}
+}
+export {
+  RefsManager as default
+};

package/Base/managers/ServicesManager.cjs

@@ -0,0 +1,134 @@
+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) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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);
+  return value;
+};
+
+// packages/js-toolkit/Base/managers/ServicesManager.js
+var ServicesManager_exports = {};
+__export(ServicesManager_exports, {
+  default: () => ServicesManager
+});
+module.exports = __toCommonJS(ServicesManager_exports);
+var import_pointer = __toESM(require("../../services/pointer.cjs"), 1);
+var import_raf = __toESM(require("../../services/raf.cjs"), 1);
+var import_resize = __toESM(require("../../services/resize.cjs"), 1);
+var import_scroll = __toESM(require("../../services/scroll.cjs"), 1);
+var import_key = __toESM(require("../../services/key.cjs"), 1);
+var import_load = __toESM(require("../../services/load.cjs"), 1);
+var import_utils = require("../utils.cjs");
+var SERVICES_MAP = {
+  scrolled: import_scroll.default,
+  resized: import_resize.default,
+  ticked: import_raf.default,
+  moved: import_pointer.default,
+  keyed: import_key.default,
+  loaded: import_load.default
+};
+var SERVICE_NAMES = Object.keys(SERVICES_MAP);
+var ServicesManager = class {
+  constructor(instance) {
+    __publicField(this, "__base");
+    __publicField(this, "__customServices", {});
+    Object.defineProperties(this, {
+      __base: {
+        enumerable: false,
+        writable: false,
+        value: instance
+      }
+    });
+  }
+  get __services() {
+    return {
+      ...this.__customServices,
+      ...SERVICES_MAP
+    };
+  }
+  has(service) {
+    if (!(((0, import_utils.hasMethod)(this.__base, service) || this.__base.__hasEvent(service)) && this.__services[service])) {
+      return false;
+    }
+    const { has } = this.__services[service]();
+    return has(this.__base.$id);
+  }
+  get(service) {
+    return this.__services[service]().props();
+  }
+  enable(service) {
+    if (this.has(service)) {
+      return this.disable.bind(this, service);
+    }
+    if (!((0, import_utils.hasMethod)(this.__base, service) || this.__base.__hasEvent(service)) || !this.__services[service]) {
+      return function noop() {
+      };
+    }
+    const { add } = this.__services[service]();
+    const self = this;
+    function serviceHandler(...args) {
+      self.__base.__callMethod(service, ...args);
+    }
+    add(this.__base.$id, serviceHandler);
+    return this.disable.bind(this, service);
+  }
+  enableAll() {
+    return Object.keys(this.__services).map((serviceName) => this.enable(serviceName));
+  }
+  disableAll() {
+    Object.keys(this.__services).forEach((serviceName) => {
+      this.disable(serviceName);
+    });
+  }
+  disable(service) {
+    if (!this.__services[service]) {
+      return;
+    }
+    const { remove } = this.__services[service]();
+    remove(this.__base.$id);
+  }
+  toggle(service, force) {
+    if (typeof force !== "undefined") {
+      if (force && !this.has(service)) {
+        this.enable(service);
+      }
+      if (!force && this.has(service)) {
+        this.disable(service);
+      }
+    } else if (this.has(service)) {
+      this.disable(service);
+    } else {
+      this.enable(service);
+    }
+  }
+  register(name, useFunction) {
+    this.__customServices[name] = useFunction;
+    this.__base.__addEmits(name);
+  }
+  unregister(name) {
+    if (SERVICE_NAMES.includes(name)) {
+      throw new Error(`[ServicesManager] The \`${name}\` core service can not be unregistered.`);
+    }
+    this.__base.__removeEmits(name);
+    delete this.__customServices[name];
+  }
+};
+if (module.exports.default) module.exports = module.exports.default;

package/Base/managers/ServicesManager.d.ts

@@ -23,47 +23,53 @@ export default class ServicesManager {
      */
     __customServices: Record<string, () => ServiceInterface>;
     /**
-     * @return {Record<string, () => ServiceInterface>}
+     * @returns {Record<string, () => ServiceInterface>}
      */
     get __services(): Record<string, () => ServiceInterface>;
     /**
      * Test if the given service is registered.
      *
      * @param  {ServiceName} service The name of the service.
-     * @return {Boolean}
+     * @returns {boolean}
      */
     has(service: ServiceName): boolean;
+    /**
+     * Get a service props by name.
+     * @param   {ServiceName} service The name of the service.
+     * @returns {ReturnType<ServiceInterface['props']>}
+     */
+    get(service: ServiceName): ReturnType<ServiceInterface['props']>;
     /**
      * Init the given service and bind it to the given instance.
      *
      * @param  {ServiceName} service The name of the service.
-     * @return {() => void}          A function to unbind the service.
+     * @returns {() => void}          A function to unbind the service.
      */
     enable(service: ServiceName): () => void;
     /**
      * Enable all services and return methods to disable them.
      *
-     * @return {Function[]}
+     * @returns {Function[]}
      */
     enableAll(): Function[];
     /**
      * Disable all services.
      *
-     * @return {void}
+     * @returns {void}
      */
     disableAll(): void;
     /**
      * Disable a service.
      *
-     * @param  {String} service  The name of the service.
-     * @return {void}
+     * @param  {string} service  The name of the service.
+     * @returns {void}
      */
     disable(service: string): void;
     /**
      * Toggle a service.
      * @param  {string}  service    The name of the service.
      * @param  {boolean} [force] The state to force.
-     * @return {void}
+     * @returns {void}
      */
     toggle(service: string, force?: boolean): void;
     /**