@studiometa/js-toolkit 2.0.1 → 2.2.0-alpha.1

package/Base/managers/OptionsManager.d.ts

@@ -1,66 +1,24 @@
 /**
- * @typedef {import('deepmerge').Options} DeepmergeOptions
- * @typedef {import('../index.js').BaseConfig} BaseConfig
- * @typedef {StringConstructor|NumberConstructor|BooleanConstructor|ArrayConstructor|ObjectConstructor} OptionType
- * @typedef {{type: OptionType, default: string | number | boolean | (() => Array | Object), merge?: boolean | DeepmergeOptions}} OptionObject
- * @typedef {OptionType | OptionObject} OptionValue
- * @typedef {{ [name:string]: OptionValue }} OptionsSchema
- * @typedef {{ [optionName:string]: any }} OptionsInterface
+ * Get a property name.
+ *
+ * @param  {string} name
+ * @param  {string} [prefix]
+ * @returns {string}
+ * @protected
  */
+export function __getPropertyName(name: string, prefix?: string): string;
 /**
  * Class options to manage options as data attributes on an HTML element.
  *
  * @todo Use `MutationObserver` to update values? Might be more performant.
- * @augments {OptionsInterface}
  */
-export default class OptionsManager {
-    /**
-     * List of allowed types.
-     * @type {Array}
-     * @private
-     */
-    private static types;
-    /**
-     * Property name cache.
-     * @type {Map}
-     * @private
-     */
-    private static __propertyNameCache;
-    /**
-     * Get a property name.
-     *
-     * @param  {string} name
-     * @param  {string} [prefix]
-     * @returns {string}
-     * @private
-     */
-    private static __getPropertyName;
-    /**
-     * Class constructor.
-     *
-     * @param {HTMLElement}   element The HTML element storing the options.
-     * @param {OptionsSchema} schema  A Base class config options.
-     * @param {BaseConfig}    baseConfig  A Base class config.
-     */
-    constructor(element: HTMLElement, schema: OptionsSchema, baseConfig: BaseConfig);
-    /**
-     * The HTML element holding the options attributes.
-     * @type {HTMLElement}
-     * @private
-     */
-    private __element;
+export default class OptionsManager extends AbstractManager {
     /**
      * An object to store Array and Object values for reference.
      * @type {Object}
      * @private
      */
     private __values;
-    /**
-     * The default values to return for each available type.
-     * @type {Object}
-     * @private
-     */
-    private __defaultValues;
     /**
      * Default value for the name property.
      * @type {string}
@@ -76,54 +34,54 @@ export default class OptionsManager {
      * @type {boolean}
      */
     log: boolean;
-    /**
-     * Register an option.
-     *
-     * @param  {string} name
-     * @param  {OptionValue} config
-     * @returns {void}
-     * @private
-     */
-    private __register;
     /**
      * Get an option value.
      *
      * @param   {string} name The option name.
-     * @param   {OptionType} type The option data's type.
-     * @param   {any} defaultValue The default value for this option.
-     * @param   {boolean|DeepmergeOptions} [merge] Wether to merge the value with the default or not.
+     * @param   {OptionObject} config The option config.
      * @returns {any}
      */
-    get(name: string, type: OptionType, defaultValue: any, merge?: boolean | DeepmergeOptions): any;
+    get(name: string, config: OptionObject): any;
     /**
      * Set an option value.
      *
      * @param {string} name The option name.
-     * @param {OptionType} type The option data's type.
      * @param {any} value The new value for this option.
-     * @param {any} defaultValue The default value for this option.
-     */
-    set(name: string, type: OptionType, value: any, defaultValue: any): void;
-    /**
-     * Test if the element has a given property.
-     *
-     * @param  {string} prop
-     * @returns {boolean}
+     * @param {OptionObject} config The option config.
      */
-    __hasProperty(prop: string): boolean;
+    set(name: string, value: any, config: OptionObject): void;
 }
 export type DeepmergeOptions = import('deepmerge').Options;
+export type Base = import('../index.js').default;
 export type BaseConfig = import('../index.js').BaseConfig;
 export type OptionType = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor;
-export type OptionObject = {
-    type: OptionType;
-    default: string | number | boolean | (() => any[] | any);
-    merge?: boolean | DeepmergeOptions;
+export type ArrayOption = {
+    type: ArrayConstructor;
+    default?: () => any[];
+    merge?: boolean;
+};
+export type ObjectOption = {
+    type: ObjectConstructor;
+    default?: () => any;
+    merge?: boolean;
+};
+export type StringOption = {
+    type: StringConstructor;
+    default?: string;
+};
+export type NumberOption = {
+    type: NumberConstructor;
+    default?: number;
+};
+export type BooleanOption = {
+    type: BooleanConstructor;
+    default?: boolean;
 };
-export type OptionValue = OptionType | OptionObject;
+export type OptionObject = ArrayOption | ObjectOption | StringOption | NumberOption | BooleanOption;
 export type OptionsSchema = {
-    [name: string]: OptionValue;
+    [name: string]: OptionType | OptionObject;
 };
 export type OptionsInterface = {
     [optionName: string]: any;
 };
+import AbstractManager from "./AbstractManager.js";

package/Base/managers/OptionsManager.js

@@ -5,80 +5,79 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 import deepmerge from "deepmerge";
+import AbstractManager from "./AbstractManager.js";
 import isObject from "../../utils/object/isObject.js";
-const _OptionsManager = class {
-  constructor(element, schema, baseConfig) {
-    __publicField(this, "__element");
+const types = /* @__PURE__ */ new Set([String, Number, Boolean, Array, Object]);
+const __defaultValues = {
+  String: "",
+  Number: 0,
+  Boolean: false,
+  Array: () => [],
+  Object: () => ({})
+};
+function __hasProperty(that, prop) {
+  return typeof that.__element.dataset[prop] !== "undefined";
+}
+const __propertyNameCache = /* @__PURE__ */ new Map();
+function __getPropertyName(name, prefix = "") {
+  const key = name + prefix;
+  if (__propertyNameCache.has(key)) {
+    return __propertyNameCache.get(key);
+  }
+  const propertyName = `option${prefix}${name.replace(/^\w/, (c) => c.toUpperCase())}`;
+  __propertyNameCache.set(key, propertyName);
+  return propertyName;
+}
+function __register(that, name, config) {
+  var _a;
+  if (!types.has(config.type)) {
+    throw new Error(`The "${name}" option has an invalid type. The allowed types are: String, Number, Boolean, Array and Object.`);
+  }
+  config.default = (_a = config.default) != null ? _a : __defaultValues[config.type.name];
+  if ((config.type === Array || config.type === Object) && typeof config.default !== "function") {
+    throw new Error(`The default value for options of type "${config.type.name}" must be returned by a function.`);
+  }
+  Object.defineProperty(that, name, {
+    get: () => {
+      return that.get(name, config);
+    },
+    set: (value) => {
+      that.set(name, value, config);
+    },
+    enumerable: true
+  });
+}
+class OptionsManager extends AbstractManager {
+  constructor(base) {
+    super(base);
     __publicField(this, "__values", {});
-    __publicField(this, "__defaultValues", {
-      String: "",
-      Number: 0,
-      Boolean: false,
-      Array: () => [],
-      Object: () => ({})
-    });
     __publicField(this, "name", "Base");
     __publicField(this, "debug", false);
     __publicField(this, "log", false);
     var _a, _b;
-    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;
+    this.__hideProperties(["__values", "__defaultValues"]);
+    const schema = this.__config.options || {};
+    this.name = this.__config.name;
     schema.debug = {
       type: Boolean,
-      default: (_a = baseConfig.debug) != null ? _a : false
+      default: (_a = this.__config.debug) != null ? _a : false
     };
     schema.log = {
       type: Boolean,
-      default: (_b = baseConfig.log) != null ? _b : false
+      default: (_b = this.__config.log) != null ? _b : false
     };
     Object.entries(schema).forEach(([name, config]) => {
-      this.__register(name, config);
+      __register(this, name, types.has(config) ? { type: config } : config);
     });
   }
-  __register(name, config) {
-    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.`);
-    }
-    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, isObjectConfig ? config.merge : void 0);
-      },
-      set: (value) => {
-        this.set(name, type, value, defaultValue);
-      },
-      enumerable: true
-    });
-  }
-  get(name, type, defaultValue, merge) {
-    const propertyName = _OptionsManager.__getPropertyName(name);
-    const hasProperty = this.__hasProperty(propertyName);
+  get(name, config) {
+    const { type, default: defaultValue } = config;
+    const propertyName = __getPropertyName(name);
+    const hasProperty = __hasProperty(this, propertyName);
     if (type === Boolean) {
       if (defaultValue) {
-        const negatedPropertyName = _OptionsManager.__getPropertyName(name, "No");
-        const hasNegatedProperty = this.__hasProperty(negatedPropertyName);
+        const negatedPropertyName = __getPropertyName(name, "No");
+        const hasNegatedProperty = __hasProperty(this, negatedPropertyName);
         return !hasNegatedProperty;
       }
       return hasProperty || defaultValue;
@@ -88,10 +87,11 @@ const _OptionsManager = class {
       return hasProperty ? Number(value) : defaultValue;
     }
     if (type === Array || type === Object) {
+      config = type === Array ? config : config;
       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);
+        let val = hasProperty ? JSON.parse(value) : config.default();
+        if (typeof config.merge !== "undefined") {
+          val = typeof config.merge === "boolean" ? deepmerge(config.default(), val) : deepmerge(config.default(), val, config.merge);
         }
         this.__values[name] = val;
       }
@@ -99,8 +99,9 @@ const _OptionsManager = class {
     }
     return hasProperty ? value : defaultValue;
   }
-  set(name, type, value, defaultValue) {
-    const propertyName = _OptionsManager.__getPropertyName(name);
+  set(name, value, config) {
+    const { type, default: defaultValue } = config;
+    const propertyName = __getPropertyName(name);
     if (value.constructor.name !== 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}"`);
@@ -108,7 +109,7 @@ const _OptionsManager = class {
     switch (type) {
       case Boolean:
         if (defaultValue) {
-          const negatedPropertyName = _OptionsManager.__getPropertyName(name, "No");
+          const negatedPropertyName = __getPropertyName(name, "No");
           if (value) {
             delete this.__element.dataset[negatedPropertyName];
           } else {
@@ -128,22 +129,8 @@ const _OptionsManager = class {
         this.__element.dataset[propertyName] = value;
     }
   }
-  __hasProperty(prop) {
-    return typeof this.__element.dataset[prop] !== "undefined";
-  }
-  static __getPropertyName(name, prefix = "") {
-    const key = name + prefix;
-    if (_OptionsManager.__propertyNameCache.has(key)) {
-      return _OptionsManager.__propertyNameCache.get(key);
-    }
-    const propertyName = `option${prefix}${name.replace(/^\w/, (c) => c.toUpperCase())}`;
-    _OptionsManager.__propertyNameCache.set(key, propertyName);
-    return propertyName;
-  }
-};
-let OptionsManager = _OptionsManager;
-__publicField(OptionsManager, "types", [String, Number, Boolean, Array, Object]);
-__publicField(OptionsManager, "__propertyNameCache", /* @__PURE__ */ new Map());
+}
 export {
+  __getPropertyName,
   OptionsManager as default
 };

package/Base/managers/RefsManager.cjs

@@ -1,8 +1,9 @@
+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 });
@@ -15,85 +16,60 @@ 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);
-  return value;
-};
 
 // packages/js-toolkit/Base/managers/RefsManager.js
 var RefsManager_exports = {};
 __export(RefsManager_exports, {
-  default: () => RefsManager
+  default: () => RefsManager,
+  normalizeRefName: () => normalizeRefName
 });
 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));
+var import_AbstractManager = __toESM(require("./AbstractManager.cjs"), 1);
+function normalizeRefName(name) {
+  return name.endsWith("[]") ? name.replace(/\[\]$/, "") : name;
+}
+function __filterRefsBelongingToInstance(that, ref) {
+  let ancestor = ref.parentElement;
+  while (ancestor && ancestor.dataset.component === void 0) {
+    ancestor = ancestor.parentElement;
   }
-  unregisterAll() {
-    this.__refs.forEach((refName) => this.__unregister(refName));
+  return ancestor === null || ancestor === that.__element;
+}
+function __register(that, refName) {
+  const isMultiple = refName.endsWith("[]");
+  const propName = normalizeRefName(refName);
+  const refs = Array.from(that.__element.querySelectorAll(`[data-ref="${refName}"]`)).filter((ref) => __filterRefsBelongingToInstance(that, ref));
+  if (!isMultiple && refs.length > 1) {
+    console.warn(`[${that.__base.$options.name}]`, `The "${refName}" ref has been found multiple times.`, "Did you forgot to add the `[]` suffix to its name?");
   }
-  __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
-    });
+  if (!isMultiple && refs.length <= 1 && refs[0] === void 0) {
+    console.warn(`[${that.__base.$options.name}]`, `The "${refName}" ref is missing.`, `Is there an \`[data-ref="${refName}"]\` element in the component's scope?`);
+    return;
   }
-  __unregister(refName) {
-    const propName = RefsManager.normalizeRefName(refName);
-    const refs = Array.isArray(this[propName]) ? this[propName] : [this[propName]];
-    this.__eventsManager.unbindRef(refName, refs);
+  that.__eventsManager.bindRef(refName, refs);
+  Object.defineProperty(that, propName, {
+    value: isMultiple || refs.length > 1 ? refs : refs[0],
+    enumerable: true,
+    configurable: true
+  });
+}
+function __unregister(that, refName) {
+  const propName = normalizeRefName(refName);
+  const refs = Array.isArray(that[propName]) ? that[propName] : [that[propName]];
+  that.__eventsManager.unbindRef(refName, refs);
+}
+var RefsManager = class extends import_AbstractManager.default {
+  get __refs() {
+    var _a;
+    return (_a = this.__config.refs) != null ? _a : [];
   }
-  static normalizeRefName(name) {
-    return name.endsWith("[]") ? name.replace(/\[\]$/, "") : name;
+  registerAll() {
+    this.__refs.forEach((refName) => __register(this, refName));
   }
-  __filterRefsBelongingToInstance(ref) {
-    let ancestor = ref.parentElement;
-    while (ancestor && ancestor.dataset.component === void 0) {
-      ancestor = ancestor.parentElement;
-    }
-    return ancestor === null || ancestor === this.__element;
+  unregisterAll() {
+    this.__refs.forEach((refName) => __unregister(this, refName));
   }
 };
 if (module.exports.default) module.exports = module.exports.default;

package/Base/managers/RefsManager.d.ts

@@ -1,52 +1,21 @@
 /**
- * @typedef {import('../index.js').default} Base
- * @typedef {import('./EventsManager.js').default} EventsManager
+ * Normalize the name of ref.
+ *
+ * @param {string} name The original name.
+ * @returns {string}     The normalized name.
  */
+export function normalizeRefName(name: string): string;
 /**
  * Refs Manager
  *
  * @todo Use `MutationObserver` to automatically update refs?
  */
-export default class RefsManager {
-    /**
-     * Normalize the name of ref.
-     *
-     * @param {string} name The original name.
-     * @returns {string}     The normalized name.
-     */
-    static normalizeRefName(name: string): string;
-    /**
-     * Class constructor.
-     *
-     * @param {Base} base
-     *   The base instance tied to this manager.
-     * @param {HTMLElement} element
-     *   The root element of a Base component.
-     * @param {string[]} refs
-     *   The list of refs of this component.
-     * @param {EventsManager} eventsManager
-     */
-    constructor(base: Base, element: HTMLElement, refs: string[], eventsManager: EventsManager);
-    /**
-     * @type {HTMLElement}
-     * @private
-     */
-    private __element;
-    /**
-     * @type {string[]}
-     * @private
-     */
-    private __refs;
+export default class RefsManager extends AbstractManager {
     /**
-     * @type {Base}
-     * @private
+     * Get refs configuration.
+     * @returns {string[]}
      */
-    private __base;
-    /**
-     * @type {EventsManager}
-     * @private
-     */
-    private __eventsManager;
+    get __refs(): string[];
     /**
      * Register all refs.
      *
@@ -59,28 +28,5 @@ export default class RefsManager {
      * @returns {void}
      */
     unregisterAll(): void;
-    /**
-     * Register one ref.
-     *
-     * @param {string} refName The ref name.
-     * @private
-     */
-    private __register;
-    /**
-     * Unregister one ref.
-     *
-     * @param {string} refName The ref name.
-     * @private
-     */
-    private __unregister;
-    /**
-     * Filter refs belonging to the related Base instance.
-     *
-     * @param {HTMLElement} ref The ref to test.
-     * @returns {boolean}
-     * @private
-     */
-    private __filterRefsBelongingToInstance;
 }
-export type Base = import('../index.js').default;
-export type EventsManager = import('./EventsManager.js').default;
+import AbstractManager from "./AbstractManager.js";