@studiometa/js-toolkit 2.4.7 → 2.6.0

package/Base/managers/OptionsManager.d.ts

@@ -1,87 +1,74 @@
+import type { Options as DeepmergeOptions } from 'deepmerge';
+import { AbstractManager } from './AbstractManager.js';
+import type { Base } from '../index.js';
+declare type OptionType = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor;
+declare type ArrayOption = {
+    type: ArrayConstructor;
+    default?: () => unknown[];
+    merge?: boolean | DeepmergeOptions;
+};
+declare type ObjectOption = {
+    type: ObjectConstructor;
+    default?: () => unknown;
+    merge?: boolean | DeepmergeOptions;
+};
+declare type StringOption = {
+    type: StringConstructor;
+    default?: string;
+};
+declare type NumberOption = {
+    type: NumberConstructor;
+    default?: number;
+};
+declare type BooleanOption = {
+    type: BooleanConstructor;
+    default?: boolean;
+};
+export declare type OptionObject = ArrayOption | ObjectOption | StringOption | NumberOption | BooleanOption;
+export declare type OptionsSchema = {
+    [name: string]: OptionType | OptionObject;
+};
+export declare type OptionsInterface = {
+    [optionName: string]: unknown;
+};
 /**
  * Get a property name.
- *
- * @param  {string} name
- * @param  {string} [prefix]
- * @returns {string}
- * @protected
  */
-export function __getPropertyName(name: string, prefix?: string): string;
+export declare 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.
  */
-export default class OptionsManager extends AbstractManager {
+export declare class OptionsManager extends AbstractManager {
     /**
      * An object to store Array and Object values for reference.
-     * @type {Object}
      * @private
      */
-    private __values;
+    __values: {};
     /**
      * Default value for the name property.
-     * @type {string}
      */
     name: string;
     /**
      * Default value for the debug property.
-     * @type {boolean}
      */
     debug: boolean;
     /**
      * Default value for the log property.
-     * @type {boolean}
      */
     log: boolean;
+    /**
+     * Class constructor.
+     */
+    constructor(base: Base);
     /**
      * Get an option value.
-     *
-     * @param   {string} name The option name.
-     * @param   {OptionObject} config The option config.
-     * @returns {any}
      */
     get(name: string, config: OptionObject): any;
     /**
      * Set an option value.
-     *
-     * @param {string} name The option name.
-     * @param {any} value The new value for this option.
-     * @param {OptionObject} config The option config.
      */
-    set(name: string, value: any, config: OptionObject): void;
+    set(name: string, value: unknown, config: OptionObject): void;
 }
-export type DeepmergeOptions = import('deepmerge').Options;
-export type Base = import('../index.js').Base;
-export type BaseConfig = import('../index.js').BaseConfig;
-export type OptionType = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor;
-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 OptionObject = ArrayOption | ObjectOption | StringOption | NumberOption | BooleanOption;
-export type OptionsSchema = {
-    [name: string]: OptionObject | OptionType;
-};
-export type OptionsInterface = {
-    [optionName: string]: any;
-};
-import AbstractManager from "./AbstractManager.js";
+export {};

package/Base/managers/OptionsManager.js

@@ -5,7 +5,7 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 import deepmerge from "deepmerge";
-import AbstractManager from "./AbstractManager.js";
+import { AbstractManager } from "./AbstractManager.js";
 import { isDev, isFunction, isDefined, isBoolean, isArray, isObject } from "../../utils/index.js";
 const types = /* @__PURE__ */ new Set([String, Number, Boolean, Array, Object]);
 const __defaultValues = {
@@ -45,9 +45,7 @@ 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);
     },
@@ -147,6 +145,6 @@ class OptionsManager extends AbstractManager {
   }
 }
 export {
-  __getPropertyName,
-  OptionsManager as default
+  OptionsManager,
+  __getPropertyName
 };

package/Base/managers/RefsManager.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 __export = (target, all) => {
   for (var name in all)
@@ -16,23 +14,20 @@ 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);
 
-// packages/js-toolkit/Base/managers/RefsManager.js
+// packages/js-toolkit/Base/managers/RefsManager.ts
 var RefsManager_exports = {};
 __export(RefsManager_exports, {
-  default: () => RefsManager,
+  RefsManager: () => RefsManager,
   normalizeRefName: () => normalizeRefName
 });
 module.exports = __toCommonJS(RefsManager_exports);
-var import_AbstractManager = __toESM(require("./AbstractManager.cjs"), 1);
+var import_AbstractManager = require("./AbstractManager.cjs");
 var import_utils = require("../../utils/index.cjs");
+var NORMALIZE_REF_NAME_REGEX = /\[\]$/;
 function normalizeRefName(name) {
-  return name.endsWith("[]") ? name.replace(/\[\]$/, "") : name;
+  return name.endsWith("[]") ? name.replace(NORMALIZE_REF_NAME_REGEX, "") : name;
 }
 function __filterRefsBelongingToInstance(that, ref) {
   let ancestor = ref.parentElement;
@@ -44,9 +39,9 @@ function __filterRefsBelongingToInstance(that, ref) {
 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)
-  );
+  const refs = Array.from(
+    that.__element.querySelectorAll(`[data-ref="${refName}"]`)
+  ).filter((ref) => __filterRefsBelongingToInstance(that, ref));
   if (import_utils.isDev && !isMultiple && refs.length > 1) {
     console.warn(
       `[${that.__base.$options.name}]`,
@@ -76,7 +71,7 @@ function __unregister(that, refName) {
   const refs = (0, import_utils.isArray)(that[propName]) ? that[propName] : [that[propName]];
   that.__eventsManager.unbindRef(refName, refs);
 }
-var RefsManager = class extends import_AbstractManager.default {
+var RefsManager = class extends import_AbstractManager.AbstractManager {
   get __refs() {
     var _a;
     return (_a = this.__config.refs) != null ? _a : [];

package/Base/managers/RefsManager.d.ts

@@ -1,32 +1,24 @@
+import { AbstractManager } from './AbstractManager.js';
 /**
  * Normalize the name of ref.
- *
- * @param {string} name The original name.
- * @returns {string}     The normalized name.
  */
-export function normalizeRefName(name: string): string;
+export declare function normalizeRefName(name: string): string;
 /**
  * Refs Manager
  *
  * @todo Use `MutationObserver` to automatically update refs?
  */
-export default class RefsManager extends AbstractManager {
+export declare class RefsManager extends AbstractManager {
     /**
      * Get refs configuration.
-     * @returns {string[]}
      */
     get __refs(): string[];
     /**
      * Register all refs.
-     *
-     * @returns {void}
      */
     registerAll(): void;
     /**
      * Unregister all refs.
-     *
-     * @returns {void}
      */
     unregisterAll(): void;
 }
-import AbstractManager from "./AbstractManager.js";

package/Base/managers/RefsManager.js

@@ -1,7 +1,8 @@
-import AbstractManager from "./AbstractManager.js";
+import { AbstractManager } from "./AbstractManager.js";
 import { isDev, isArray, isDefined } from "../../utils/index.js";
+const NORMALIZE_REF_NAME_REGEX = /\[\]$/;
 function normalizeRefName(name) {
-  return name.endsWith("[]") ? name.replace(/\[\]$/, "") : name;
+  return name.endsWith("[]") ? name.replace(NORMALIZE_REF_NAME_REGEX, "") : name;
 }
 function __filterRefsBelongingToInstance(that, ref) {
   let ancestor = ref.parentElement;
@@ -13,9 +14,9 @@ function __filterRefsBelongingToInstance(that, ref) {
 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)
-  );
+  const refs = Array.from(
+    that.__element.querySelectorAll(`[data-ref="${refName}"]`)
+  ).filter((ref) => __filterRefsBelongingToInstance(that, ref));
   if (isDev && !isMultiple && refs.length > 1) {
     console.warn(
       `[${that.__base.$options.name}]`,
@@ -58,6 +59,6 @@ class RefsManager extends AbstractManager {
   }
 }
 export {
-  RefsManager as default,
+  RefsManager,
   normalizeRefName
 };

package/Base/managers/ResponsiveOptionsManager.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 __export = (target, all) => {
   for (var name in all)
@@ -16,19 +14,15 @@ 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);
 
 // packages/js-toolkit/Base/managers/ResponsiveOptionsManager.ts
 var ResponsiveOptionsManager_exports = {};
 __export(ResponsiveOptionsManager_exports, {
-  default: () => ResponsiveOptionsManager
+  ResponsiveOptionsManager: () => ResponsiveOptionsManager
 });
 module.exports = __toCommonJS(ResponsiveOptionsManager_exports);
-var import_OptionsManager = __toESM(require("./OptionsManager.cjs"), 1);
+var import_OptionsManager = require("./OptionsManager.cjs");
 var import_services = require("../../services/index.cjs");
 var import_utils = require("../../utils/index.cjs");
 function __getResponsiveName(that, name) {
@@ -48,7 +42,7 @@ function __getResponsiveName(that, name) {
   });
   return responsiveName;
 }
-var ResponsiveOptionsManager = class extends import_OptionsManager.default {
+var ResponsiveOptionsManager = class extends import_OptionsManager.OptionsManager {
   get(name, config) {
     if (!config.responsive) {
       return super.get(name, config);

package/Base/managers/ResponsiveOptionsManager.d.ts

@@ -1,8 +1,12 @@
-import OptionsManager from './OptionsManager.js';
+import { OptionsManager } from './OptionsManager.js';
+import type { OptionObject } from './OptionsManager.js';
+export declare type ResponsiveOptionObject = OptionObject & {
+    responsive?: boolean;
+};
 /**
  * Class options to manage options as data attributes on an HTML element.
  */
-export default class ResponsiveOptionsManager extends OptionsManager {
+export declare class ResponsiveOptionsManager extends OptionsManager {
     /**
      * Get an option value.
      *
@@ -10,7 +14,7 @@ export default class ResponsiveOptionsManager extends OptionsManager {
      * @param   {ResponsiveOptionObject} config The option configuration.
      * @returns {any}
      */
-    get(name: any, config: any): any;
+    get(name: string, config: ResponsiveOptionObject): any;
     /**
      * Set an option value.
      *
@@ -18,5 +22,5 @@ export default class ResponsiveOptionsManager extends OptionsManager {
      * @param {any} value The new value.
      * @param {ResponsiveOptionObject} config The option configuration.
      */
-    set(name: any, value: any, config: any): void;
+    set(name: string, value: unknown, config: ResponsiveOptionObject): void;
 }

package/Base/managers/ResponsiveOptionsManager.js

@@ -1,4 +1,4 @@
-import OptionsManager, { __getPropertyName } from "./OptionsManager.js";
+import { OptionsManager, __getPropertyName } from "./OptionsManager.js";
 import { useResize } from "../../services/index.js";
 import { isDev } from "../../utils/index.js";
 function __getResponsiveName(that, name) {
@@ -36,5 +36,5 @@ class ResponsiveOptionsManager extends OptionsManager {
   }
 }
 export {
-  ResponsiveOptionsManager as default
+  ResponsiveOptionsManager
 };

package/Base/managers/ServicesManager.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,40 +15,31 @@ 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/ServicesManager.js
+// packages/js-toolkit/Base/managers/ServicesManager.ts
 var ServicesManager_exports = {};
 __export(ServicesManager_exports, {
-  default: () => ServicesManager
+  ServicesManager: () => 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_AbstractManager = __toESM(require("./AbstractManager.cjs"), 1);
+var import_services = require("../../services/index.cjs");
+var import_AbstractManager = require("./AbstractManager.cjs");
 var import_utils = require("../../utils/index.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
+  scrolled: import_services.useScroll,
+  resized: import_services.useResize,
+  ticked: import_services.useRaf,
+  moved: import_services.usePointer,
+  keyed: import_services.useKey,
+  loaded: import_services.useLoad
 };
 var SERVICE_NAMES = Object.keys(SERVICES_MAP);
-var ServicesManager = class extends import_AbstractManager.default {
+var ServicesManager = class extends import_AbstractManager.AbstractManager {
   constructor() {
     super(...arguments);
     __publicField(this, "__customServices", {});
@@ -78,25 +67,19 @@ var ServicesManager = class extends import_AbstractManager.default {
     if (!((0, import_utils.isFunction)(this.__base[service]) || this.__base.__hasEvent(service)) || !this.__services[service]) {
       return import_utils.noop;
     }
-    const { add } = this.__services[service]();
-    const self = this;
-    function serviceHandler(...args) {
-      return self.__base.__callMethod(service, ...args);
-    }
-    add(this.__base.$id, serviceHandler);
+    const serviceInstance = this.__services[service]();
+    serviceInstance.add(this.__base.$id, (...args) => {
+      this.__base.__callMethod(service, ...args);
+    });
     return this.disable.bind(this, service);
   }
   enableAll() {
-    return Object.keys(this.__services).map(
-      (serviceName) => this.enable(serviceName)
-    );
+    return Object.keys(this.__services).map((serviceName) => this.enable(serviceName));
   }
   disableAll() {
-    Object.keys(this.__services).forEach(
-      (serviceName) => {
-        this.disable(serviceName);
-      }
-    );
+    Object.keys(this.__services).forEach((serviceName) => {
+      this.disable(serviceName);
+    });
   }
   disable(service) {
     if (!this.__services[service]) {

package/Base/managers/ServicesManager.d.ts

@@ -1,47 +1,55 @@
-/**
- * @typedef {typeof SERVICES_MAP & Record<string, () => ServiceInterface>} Services
- * @typedef {keyof SERVICES_MAP|string} ServiceName
- */
+import { usePointer, useRaf, useResize, useScroll, useKey, useLoad } from '../../services/index.js';
+import type { PointerServiceInterface, RafServiceInterface, ResizeServiceInterface, ScrollServiceInterface, KeyServiceInterface, LoadServiceInterface, ServiceInterface } from '../../services/index.js';
+import { AbstractManager } from './AbstractManager.js';
+declare type Services = {
+    scrolled: ScrollServiceInterface;
+    resized: ResizeServiceInterface;
+    ticked: RafServiceInterface;
+    moved: PointerServiceInterface;
+    keyed: KeyServiceInterface;
+    loaded: LoadServiceInterface;
+} & Record<string, ServiceInterface<unknown>>;
+declare type ServiceNames = keyof Services;
 /**
  * Services management for the Base class.
  *
  * @todo Add support for disabled services on mount when the method is defined.
  */
-export default class ServicesManager extends AbstractManager {
+export declare class ServicesManager extends AbstractManager {
     /**
-     * @type {Record<string, () => ServiceInterface>}
+     * Holder for custom services.
      */
-    __customServices: Record<string, () => import("../../services").ServiceInterface<any>>;
+    __customServices: Record<string, <T>() => ServiceInterface<T>>;
     /**
-     * @returns {Record<string, () => ServiceInterface>}
+     * Get registered services.
      */
-    get __services(): Record<string, () => import("../../services").ServiceInterface<any>>;
+    get __services(): {
+        scrolled: typeof useScroll;
+        resized: typeof useResize;
+        ticked: typeof useRaf;
+        moved: typeof usePointer;
+        keyed: typeof useKey;
+        loaded: typeof useLoad;
+    };
     /**
      * Test if the given service is registered.
-     *
-     * @param  {ServiceName} service The name of the service.
-     * @returns {boolean}
      */
-    has(service: ServiceName): boolean;
+    has(service: ServiceNames | string): boolean;
     /**
      * Get a service props by name.
-     * @param   {ServiceName} service The name of the service.
-     * @returns {ReturnType<ServiceInterface['props']>}
      */
-    get(service: ServiceName): ReturnType<import("../../services").ServiceInterface<any>['props']>;
+    get<S extends ServiceNames | string>(service: S): ReturnType<Services[S]['props']>;
     /**
      * Init the given service and bind it to the given instance.
      *
-     * @param  {ServiceName} service The name of the service.
+     * @param  {ServiceNames} service The name of the service.
      * @returns {() => void}          A function to unbind the service.
      */
-    enable(service: ServiceName): () => void;
+    enable(service: ServiceNames): () => void;
     /**
      * Enable all services and return methods to disable them.
-     *
-     * @returns {Function[]}
      */
-    enableAll(): Function[];
+    enableAll(): (() => void)[];
     /**
      * Disable all services.
      *
@@ -50,27 +58,21 @@ export default class ServicesManager extends AbstractManager {
     disableAll(): void;
     /**
      * Disable a service.
-     *
-     * @param  {string} service  The name of the service.
-     * @returns {void}
      */
-    disable(service: string): void;
+    disable(service: ServiceNames): void;
     /**
      * Toggle a service.
-     * @param  {string}  service    The name of the service.
-     * @param  {boolean} [force] The state to force.
-     * @returns {void}
      */
-    toggle(service: string, force?: boolean): void;
+    toggle(service: ServiceNames, force?: boolean): void;
     /**
      * Register a new service to be enabled/disabled.
      *
      * @param {string} name
      *   The name of the service hook.
-     * @param {() => ServiceInterface} useFunction
+     * @param {<T>(...args:unknown[]) => ServiceInterface<T>} useFunction
      *   The `use...` function for the service.
      */
-    register(name: string, useFunction: () => import("../../services").ServiceInterface<any>): void;
+    register(name: string, useFunction: <T>(...args: unknown[]) => ServiceInterface<T>): void;
     /**
      * Unregister a new service to be enabled disabled.
      *
@@ -79,31 +81,4 @@ export default class ServicesManager extends AbstractManager {
      */
     unregister(name: string): void;
 }
-export type Base = import('../index').Base;
-export type BaseConstructor = import('../index').BaseConstructor;
-export type ServiceInterface = import('../../services').ServiceInterface<any>;
-export type Services = typeof SERVICES_MAP & Record<string, () => import("../../services").ServiceInterface<any>>;
-export type ServiceName = keyof {
-    scrolled: typeof useScroll;
-    resized: typeof useResize;
-    ticked: typeof useRaf;
-    moved: typeof usePointer;
-    keyed: typeof useKey;
-    loaded: typeof useLoad;
-} | string;
-import AbstractManager from "./AbstractManager.js";
-declare namespace SERVICES_MAP {
-    export { useScroll as scrolled };
-    export { useResize as resized };
-    export { useRaf as ticked };
-    export { usePointer as moved };
-    export { useKey as keyed };
-    export { useLoad as loaded };
-}
-import useScroll from "../../services/scroll.js";
-import useResize from "../../services/resize.js";
-import useRaf from "../../services/raf.js";
-import usePointer from "../../services/pointer.js";
-import useKey from "../../services/key.js";
-import useLoad from "../../services/load.js";
 export {};

package/Base/managers/ServicesManager.js

@@ -4,13 +4,8 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-import usePointer from "../../services/pointer.js";
-import useRaf from "../../services/raf.js";
-import useResize from "../../services/resize.js";
-import useScroll from "../../services/scroll.js";
-import useKey from "../../services/key.js";
-import useLoad from "../../services/load.js";
-import AbstractManager from "./AbstractManager.js";
+import { usePointer, useRaf, useResize, useScroll, useKey, useLoad } from "../../services/index.js";
+import { AbstractManager } from "./AbstractManager.js";
 import { noop, isFunction, isDefined, isDev } from "../../utils/index.js";
 const SERVICES_MAP = {
   scrolled: useScroll,
@@ -49,25 +44,19 @@ class ServicesManager extends AbstractManager {
     if (!(isFunction(this.__base[service]) || this.__base.__hasEvent(service)) || !this.__services[service]) {
       return noop;
     }
-    const { add } = this.__services[service]();
-    const self = this;
-    function serviceHandler(...args) {
-      return self.__base.__callMethod(service, ...args);
-    }
-    add(this.__base.$id, serviceHandler);
+    const serviceInstance = this.__services[service]();
+    serviceInstance.add(this.__base.$id, (...args) => {
+      this.__base.__callMethod(service, ...args);
+    });
     return this.disable.bind(this, service);
   }
   enableAll() {
-    return Object.keys(this.__services).map(
-      (serviceName) => this.enable(serviceName)
-    );
+    return Object.keys(this.__services).map((serviceName) => this.enable(serviceName));
   }
   disableAll() {
-    Object.keys(this.__services).forEach(
-      (serviceName) => {
-        this.disable(serviceName);
-      }
-    );
+    Object.keys(this.__services).forEach((serviceName) => {
+      this.disable(serviceName);
+    });
   }
   disable(service) {
     if (!this.__services[service]) {
@@ -106,5 +95,5 @@ class ServicesManager extends AbstractManager {
   }
 }
 export {
-  ServicesManager as default
+  ServicesManager
 };