@studiometa/js-toolkit 2.0.0-rc.2 → 2.1.0

package/Base/managers/OptionsManager.cjs

@@ -27,85 +27,84 @@ var __publicField = (obj, key, value) => {
 // packages/js-toolkit/Base/managers/OptionsManager.js
 var OptionsManager_exports = {};
 __export(OptionsManager_exports, {
+  __getPropertyName: () => __getPropertyName,
   default: () => OptionsManager
 });
 module.exports = __toCommonJS(OptionsManager_exports);
 var import_deepmerge = __toESM(require("deepmerge"), 1);
+var import_AbstractManager = __toESM(require("./AbstractManager.cjs"), 1);
 var import_isObject = __toESM(require("../../utils/object/isObject.cjs"), 1);
-var _OptionsManager = class {
-  constructor(element, schema, baseConfig) {
-    __publicField(this, "__element");
+var types = /* @__PURE__ */ new Set([String, Number, Boolean, Array, Object]);
+var __defaultValues = {
+  String: "",
+  Number: 0,
+  Boolean: false,
+  Array: () => [],
+  Object: () => ({})
+};
+function __hasProperty(that, prop) {
+  return typeof that.__element.dataset[prop] !== "undefined";
+}
+var __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
+  });
+}
+var OptionsManager = class extends import_AbstractManager.default {
+  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);
     });
-    return this;
   }
-  __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;
@@ -115,10 +114,11 @@ var _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" ? (0, import_deepmerge.default)(defaultValue(), val) : (0, import_deepmerge.default)(defaultValue(), val, merge);
+        let val = hasProperty ? JSON.parse(value) : config.default();
+        if (typeof config.merge !== "undefined") {
+          val = typeof config.merge === "boolean" ? (0, import_deepmerge.default)(config.default(), val) : (0, import_deepmerge.default)(config.default(), val, config.merge);
         }
         this.__values[name] = val;
       }
@@ -126,8 +126,9 @@ var _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) || (0, import_isObject.default)(value) ? JSON.stringify(value) : value;
       throw new TypeError(`The "${val}" value for the "${name}" option must be of type "${type.name}"`);
@@ -135,7 +136,7 @@ var _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 {
@@ -155,20 +156,5 @@ var _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;
-  }
 };
-var OptionsManager = _OptionsManager;
-__publicField(OptionsManager, "types", [String, Number, Boolean, Array, Object]);
-__publicField(OptionsManager, "__propertyNameCache", /* @__PURE__ */ new Map());
 if (module.exports.default) module.exports = module.exports.default;

package/Base/managers/OptionsManager.d.ts

@@ -1,65 +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
-     * @return {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}
@@ -72,55 +31,57 @@ export default class OptionsManager {
     debug: boolean;
     /**
      * Default value for the log property.
-     * @type {Boolean}
+     * @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 {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   {string} name The option name.
+     * @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 {string} name The option name.
      * @param {any} value The new value for this option.
+     * @param {OptionObject} config The option config.
      */
-    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;
+    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,81 +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);
     });
-    return this;
   }
-  __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;
@@ -89,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;
       }
@@ -100,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}"`);
@@ -109,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 {
@@ -129,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
 };