@studiometa/js-toolkit 2.0.0-alpha.1 → 2.0.0-alpha.10

package/Base/managers/OptionsManager.d.ts

@@ -1,3 +1,11 @@
+/**
+ * @typedef {import('../index.js').BaseConfig} BaseConfig
+ * @typedef {StringConstructor|NumberConstructor|BooleanConstructor|ArrayConstructor|ObjectConstructor} OptionType
+ * @typedef {{ type: OptionType, default: String|Number|Boolean|(() => Array|Object)}} OptionWithDefault
+ * @typedef {OptionType | OptionWithDefault} OptionValue
+ * @typedef {{ [name:string]: OptionValue }} OptionsSchema
+ * @typedef {{ [optionName:string]: any }} OptionsInterface
+ */
 /**
  * Class options to manage options as data attributes on an HTML element.
  * @augments {OptionsInterface}
@@ -9,6 +17,20 @@ export default class OptionsManager {
      * @private
      */
     private static types;
+    /**
+     * Property name cache.
+     * @type {Map}
+     * @private
+     */
+    private static __propertyNameCache;
+    /**
+     * Get a property name.
+     *
+     * @param  {string} name
+     * @return {string}
+     * @private
+     */
+    private static __getPropertyName;
     /**
      * Class constructor.
      *
@@ -50,26 +72,49 @@ export default class OptionsManager {
      * @type {Boolean}
      */
     log: boolean;
+    /**
+     * Register an option.
+     *
+     * @param  {string} name
+     * @param  {OptionValue} config
+     * @return {void}
+     * @private
+     */
+    private __register;
     /**
      * Get an option value.
      *
      * @param {String} name The option name.
-     * @param {ArrayConstructor|ObjectConstructor|StringConstructor|NumberConstructor|BooleanConstructor} type The option data's type.
+     * @param {OptionType} type The option data's type.
      * @param {any} defaultValue The default value for this option.
      */
-    get(name: string, type: ArrayConstructor | ObjectConstructor | StringConstructor | NumberConstructor | BooleanConstructor, defaultValue: any): any;
+    get(name: string, type: OptionType, defaultValue: any): any;
     /**
      * Set an option value.
      *
      * @param {String} name The option name.
-     * @param {ArrayConstructor|ObjectConstructor|StringConstructor|NumberConstructor|BooleanConstructor} type The option data's type.
+     * @param {OptionType} type The option data's type.
      * @param {any} value The new value for this option.
      */
-    set(name: string, type: ArrayConstructor | ObjectConstructor | StringConstructor | NumberConstructor | BooleanConstructor, value: any, defaultValue: any): void;
+    set(name: string, type: OptionType, value: any, defaultValue: any): void;
+    /**
+     * Test if the element has a given property.
+     *
+     * @param  {string} prop
+     * @return {boolean}
+     */
+    __hasProperty(prop: string): boolean;
 }
 export type BaseConfig = import('../index.js').BaseConfig;
 export type OptionType = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor;
-export type OptionsSchema = OptionsSchema;
+export type OptionWithDefault = {
+    type: OptionType;
+    default: string | number | boolean | (() => any[] | any);
+};
+export type OptionValue = OptionType | OptionWithDefault;
+export type OptionsSchema = {
+    [name: string]: OptionValue;
+};
 export type OptionsInterface = {
     [optionName: string]: any;
 };

package/Base/managers/OptionsManager.js

@@ -1,27 +1,9 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import deepmerge from 'deepmerge';
-import { noCase } from 'no-case';
-import mem from 'mem';
 import isObject from '../../utils/object/isObject.js';
-
-function getAttributeName(name) {
-  return "data-option-".concat(noCase(name, {
-    delimiter: '-'
-  }));
-}
-
-var memoizedGetAttributeName = mem(getAttributeName);
-
-var OptionsManager = function () {
-  function OptionsManager(element, schema, baseConfig) {
-    var _baseConfig$debug,
-        _baseConfig$log,
-        _this = this;
-
-    _classCallCheck(this, OptionsManager);
+export default class OptionsManager {
+  constructor(element, schema, baseConfig) {
+    var _baseConfig$debug, _baseConfig$log;
 
     _defineProperty(this, "__element", void 0);
 
@@ -31,12 +13,8 @@ var OptionsManager = function () {
       String: '',
       Number: 0,
       Boolean: false,
-      Array: function Array() {
-        return [];
-      },
-      Object: function Object() {
-        return {};
-      }
+      Array: () => [],
+      Object: () => ({})
     });
 
     _defineProperty(this, "name", 'Base');
@@ -45,7 +23,23 @@ var OptionsManager = function () {
 
     _defineProperty(this, "log", false);
 
-    this.__element = element;
+    Object.defineProperties(this, {
+      __element: {
+        enumerable: false,
+        writable: false,
+        value: element
+      },
+      __values: {
+        enumerable: false,
+        writable: false,
+        value: this.__values
+      },
+      __defaultValues: {
+        enumerable: false,
+        writable: false,
+        value: this.__defaultValues
+      }
+    });
     this.name = baseConfig.name;
     schema.debug = {
       type: Boolean,
@@ -55,127 +49,132 @@ var OptionsManager = function () {
       type: Boolean,
       default: (_baseConfig$log = baseConfig.log) !== null && _baseConfig$log !== void 0 ? _baseConfig$log : false
     };
-    Object.entries(schema).forEach(function (_ref) {
-      var _ref2 = _slicedToArray(_ref, 2),
-          name = _ref2[0],
-          config = _ref2[1];
+    Object.entries(schema).forEach(_ref => {
+      var [name, config] = _ref;
 
-      var isObjectConfig = !OptionsManager.types.includes(config);
-      var type = isObjectConfig ? config.type : config;
+      this.__register(name, config);
+    });
+    return this;
+  }
 
-      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."));
-      }
+  __register(name, config) {
+    var hasDefaultValue = !OptionsManager.types.includes(config);
+    var type = hasDefaultValue ? config.type : config;
 
-      var defaultValue = isObjectConfig ? config.default : _this.__defaultValues[type.name];
+    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."));
+    }
 
-      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."));
-      }
+    var defaultValue = hasDefaultValue ? config.default : this.__defaultValues[type.name];
 
-      Object.defineProperty(_this, name, {
-        get: function get() {
-          return _this.get(name, type, defaultValue);
-        },
-        set: function set(value) {
-          _this.set(name, type, value, defaultValue);
-        },
-        enumerable: true
-      });
+    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."));
+    }
+
+    Object.defineProperty(this, name, {
+      get: () => {
+        return this.get(name, type, defaultValue);
+      },
+      set: value => {
+        this.set(name, type, value, defaultValue);
+      },
+      enumerable: true
     });
-    return this;
   }
 
-  _createClass(OptionsManager, [{
-    key: "get",
-    value: function get(name, type, defaultValue) {
-      var _this2 = this;
+  get(name, type, defaultValue) {
+    var propertyName = OptionsManager.__getPropertyName(name);
 
-      var attributeName = memoizedGetAttributeName(name);
+    var hasProperty = this.__hasProperty(propertyName);
 
-      var hasAttribute = this.__element.hasAttribute(attributeName);
+    if (type === Boolean) {
+      if (defaultValue) {
+        var negatedPropertyName = OptionsManager.__getPropertyName(name, 'No');
 
-      if (type === Boolean) {
-        if (defaultValue) {
-          var negatedAttributeName = memoizedGetAttributeName("no-".concat(name));
+        var hasNegatedProperty = this.__hasProperty(negatedPropertyName);
 
-          var hasNegatedAttribute = this.__element.hasAttribute(negatedAttributeName);
+        return !hasNegatedProperty;
+      }
 
-          return !hasNegatedAttribute;
-        }
+      return hasProperty || defaultValue;
+    }
 
-        return hasAttribute || defaultValue;
-      }
+    var value = this.__element.dataset[propertyName];
+
+    if (type === Number) {
+      return hasProperty ? Number(value) : defaultValue;
+    }
 
-      var value = this.__element.getAttribute(attributeName);
+    if (type === Array || type === Object) {
+      var val = deepmerge(defaultValue(), hasProperty ? JSON.parse(value) : this.__defaultValues[type.name]());
 
-      if (type === Number) {
-        return hasAttribute ? Number(value) : defaultValue;
+      if (!this.__values[name]) {
+        this.__values[name] = val;
       }
 
-      if (type === Array || type === Object) {
-        var val = deepmerge(defaultValue(), hasAttribute ? JSON.parse(value) : this.__defaultValues[type.name]());
+      return this.__values[name];
+    }
 
-        if (!this.__values[name]) {
-          this.__values[name] = val;
-        } else if (val !== this.__values[name]) {
-          setTimeout(function () {
-            _this2.__element.setAttribute(attributeName, JSON.stringify(_this2.__values[name]));
-          }, 0);
-        }
+    return hasProperty ? value : defaultValue;
+  }
 
-        return this.__values[name];
-      }
+  set(name, type, value, defaultValue) {
+    var propertyName = OptionsManager.__getPropertyName(name);
 
-      return hasAttribute ? value : defaultValue;
+    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, "\""));
     }
-  }, {
-    key: "set",
-    value: function set(name, type, value, defaultValue) {
-      var attributeName = memoizedGetAttributeName(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, "\""));
-      }
 
-      switch (type) {
-        case Boolean:
-          if (defaultValue) {
-            var negatedAttributeName = memoizedGetAttributeName("no-".concat(name));
-
-            if (value) {
-              this.__element.removeAttribute(negatedAttributeName);
-            } else {
-              this.__element.setAttribute(negatedAttributeName, '');
-            }
-          } else if (value) {
-            this.__element.setAttribute(attributeName, '');
+    switch (type) {
+      case Boolean:
+        if (defaultValue) {
+          var negatedPropertyName = OptionsManager.__getPropertyName(name, 'No');
+
+          if (value) {
+            delete this.__element.dataset[negatedPropertyName];
           } else {
-            this.__element.removeAttribute(attributeName);
+            this.__element.dataset[negatedPropertyName] = '';
           }
+        } else if (value) {
+          this.__element.dataset[propertyName] = '';
+        } else {
+          delete this.__element.dataset[propertyName];
+        }
 
-          break;
+        break;
 
-        case Array:
-        case Object:
-          this.__values[name] = value;
+      case Array:
+      case Object:
+        this.__values[name] = value;
+        break;
 
-          this.__element.setAttribute(attributeName, JSON.stringify(value));
+      default:
+        this.__element.dataset[propertyName] = value;
+    }
+  }
 
-          break;
+  __hasProperty(prop) {
+    return typeof this.__element.dataset[prop] !== 'undefined';
+  }
 
-        default:
-          this.__element.setAttribute(attributeName, value);
+  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);
     }
-  }]);
 
-  return OptionsManager;
-}();
+    var propertyName = "option".concat(prefix).concat(name.replace(/^\w/, c => c.toUpperCase()));
+
+    OptionsManager.__propertyNameCache.set(key, propertyName);
+
+    return propertyName;
+  }
+
+}
 
 _defineProperty(OptionsManager, "types", [String, Number, Boolean, Array, Object]);
 
-export { OptionsManager as default };
-//# sourceMappingURL=OptionsManager.js.map
+_defineProperty(OptionsManager, "__propertyNameCache", new Map());

package/Base/managers/RefsManager.js

@@ -1,11 +1,6 @@
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-
-var RefsManager = function () {
-  function RefsManager(base, element, refs, eventsManager) {
-    _classCallCheck(this, RefsManager);
-
+export default class RefsManager {
+  constructor(base, element, refs, eventsManager) {
     _defineProperty(this, "__element", void 0);
 
     _defineProperty(this, "__refs", void 0);
@@ -14,81 +9,75 @@ var RefsManager = function () {
 
     _defineProperty(this, "__eventsManager", void 0);
 
-    this.__element = element;
-    this.__refs = refs;
-    this.__base = base;
-    this.__eventsManager = 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
+      }
+    });
   }
 
-  _createClass(RefsManager, [{
-    key: "registerAll",
-    value: function registerAll() {
-      var _this = this;
+  registerAll() {
+    this.__refs.forEach(refName => this.__register(refName));
+  }
 
-      this.__refs.forEach(function (refName) {
-        return _this.__register(refName);
-      });
-    }
-  }, {
-    key: "unregisterAll",
-    value: function unregisterAll() {
-      var _this2 = this;
-
-      this.__refs.forEach(function (refName) {
-        return _this2.__unregister(refName);
-      });
-    }
-  }, {
-    key: "__register",
-    value: function __register(refName) {
-      var _this3 = this;
-
-      var isMultiple = refName.endsWith('[]');
-      var propName = RefsManager.normalizeRefName(refName);
-      var refs = Array.from(this.__element.querySelectorAll("[data-ref=\"".concat(refName, "\"]"))).filter(function (ref) {
-        return _this3.__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?');
-      }
+  unregisterAll() {
+    this.__refs.forEach(refName => this.__unregister(refName));
+  }
 
-      this.__eventsManager.bindRef(refName, refs);
+  __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));
 
-      Object.defineProperty(this, propName, {
-        value: isMultiple || refs.length > 1 ? refs : refs[0],
-        enumerable: true,
-        configurable: true
-      });
+    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?');
     }
-  }, {
-    key: "__unregister",
-    value: function __unregister(refName) {
-      var propName = RefsManager.normalizeRefName(refName);
-      var refs = Array.isArray(this[propName]) ? this[propName] : [this[propName]];
 
-      this.__eventsManager.unbindRef(refName, refs);
-    }
-  }, {
-    key: "__filterRefsBelongingToInstance",
-    value: function __filterRefsBelongingToInstance(ref) {
-      var ancestor = ref.parentElement;
+    this.__eventsManager.bindRef(refName, refs);
 
-      while (ancestor && ancestor.dataset.component === undefined) {
-        ancestor = ancestor.parentElement;
-      }
+    Object.defineProperty(this, propName, {
+      value: isMultiple || refs.length > 1 ? refs : refs[0],
+      enumerable: true,
+      configurable: true
+    });
+  }
 
-      return ancestor === null || ancestor === this.__element;
-    }
-  }], [{
-    key: "normalizeRefName",
-    value: function normalizeRefName(name) {
-      return name.endsWith('[]') ? name.replace(/\[\]$/, '') : name;
+  __unregister(refName) {
+    var propName = RefsManager.normalizeRefName(refName);
+    var 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) {
+    var ancestor = ref.parentElement;
+
+    while (ancestor && ancestor.dataset.component === undefined) {
+      ancestor = ancestor.parentElement;
     }
-  }]);
 
-  return RefsManager;
-}();
+    return ancestor === null || ancestor === this.__element;
+  }
 
-export { RefsManager as default };
-//# sourceMappingURL=RefsManager.js.map
+}

package/Base/managers/ServicesManager.d.ts

@@ -15,6 +15,14 @@ export default class ServicesManager {
      * @private
      */
     private __base;
+    /**
+     * @type {Record<string, () => ServiceInterface>}
+     */
+    __customServices: Record<string, () => ServiceInterface>;
+    /**
+     * @return {Record<string, () => ServiceInterface>}
+     */
+    get __services(): Record<string, () => ServiceInterface>;
     /**
      * Test if the given service is registered.
      *
@@ -51,14 +59,17 @@ export default class ServicesManager {
     /**
      * Register a new service to be enabled/disabled.
      *
-     * @param {string}                 name        The name of the service hook.
-     * @param {() => ServiceInterface} useFunction The `use...` function for the service.
+     * @param {string} name
+     *   The name of the service hook.
+     * @param {() => ServiceInterface} useFunction
+     *   The `use...` function for the service.
      */
     register(name: string, useFunction: () => ServiceInterface): void;
     /**
      * Unregister a new service to be enabled disabled.
      *
-     * @param {string} name The name of the service hooK
+     * @param {string} name
+     *   The name of the service hook.
      */
     unregister(name: string): void;
 }