@studiometa/js-toolkit 2.4.4-alpha.3 → 2.4.4-alpha.6

package/Base/index.cjs

@@ -30,7 +30,7 @@ var __publicField = (obj, key, value) => {
 // packages/js-toolkit/Base/index.ts
 var Base_exports = {};
 __export(Base_exports, {
-  default: () => Base
+  Base: () => Base
 });
 module.exports = __toCommonJS(Base_exports);
 var import_utils = require("./utils.cjs");

package/Base/index.d.ts

@@ -3,9 +3,15 @@ import RefsManager from './managers/RefsManager.js';
 import ServicesManager from './managers/ServicesManager.js';
 import EventsManager from './managers/EventsManager.js';
 import OptionsManager from './managers/OptionsManager.js';
-export declare type BaseConstructor = typeof Base;
-export declare type BaseAsyncConstructor = (Base: any) => Promise<BaseConstructor | {
-    default: BaseConstructor;
+export declare type BaseEl = HTMLElement & {
+    __base__?: WeakMap<BaseConstructor, Base | 'terminated'>;
+};
+export declare type BaseConstructor<T extends Base = Base> = {
+    new (...args: any[]): T;
+    prototype: Base;
+} & Pick<typeof Base, keyof typeof Base>;
+export declare type BaseAsyncConstructor<T extends Base = Base> = (Base: any) => Promise<BaseConstructor<T> | {
+    default: BaseConstructor<T>;
 }>;
 export declare type BaseOptions = {
     [name: string]: unknown;
@@ -32,9 +38,7 @@ export declare type BaseTypeParameter = {
     $el?: HTMLElement;
     $options?: BaseOptions;
     $refs?: BaseRefs;
-    $children?: {
-        [name: string]: Base | Promise<Base>;
-    };
+    $children?: BaseChildren;
 };
 export declare type Managers = {
     ChildrenManager: typeof ChildrenManager;
@@ -46,7 +50,7 @@ export declare type Managers = {
 /**
  * Base class.
  */
-export default class Base<T extends BaseTypeParameter = BaseTypeParameter> extends EventTarget {
+export declare class Base<T extends BaseTypeParameter = BaseTypeParameter> extends EventTarget {
     /**
      * This is a Base instance.
      */
@@ -62,9 +66,7 @@ export default class Base<T extends BaseTypeParameter = BaseTypeParameter> exten
     /**
      * The root element.
      */
-    $el: T['$el'] & HTMLElement & {
-        __base__?: WeakMap<BaseConstructor, Base | 'terminated'>;
-    };
+    $el: T['$el'] & BaseEl;
     /**
      * The state of the component.
      */
@@ -88,21 +90,17 @@ export default class Base<T extends BaseTypeParameter = BaseTypeParameter> exten
     get $refs(): RefsManager & T['$refs'] & BaseRefs;
     __options: OptionsManager & T['$options'] & BaseOptions;
     get $options(): OptionsManager & T['$options'] & BaseOptions;
-    __children: ChildrenManager & {
-        [key in keyof T['$children']]: Array<T['$children'][key]>;
-    } & BaseChildren;
-    get $children(): ChildrenManager & {
-        [key in keyof T['$children']]: Array<T['$children'][key]>;
-    } & BaseChildren;
+    __children: ChildrenManager & T['$children'] & BaseChildren;
+    get $children(): ChildrenManager & T['$children'] & BaseChildren;
     __events: EventsManager;
     /**
      * Small helper to log stuff.
      */
-    get $log(): (...args: any) => void;
+    get $log(): (...args: unknown[]) => void;
     /**
      * Small helper to debug information.
      */
-    get __debug(): (...args: any) => void;
+    get __debug(): (...args: unknown[]) => void;
     /**
      * Get manager constructors.
      */

package/Base/index.js

@@ -289,5 +289,5 @@ __publicField(Base, "config", {
   ]
 });
 export {
-  Base as default
+  Base
 };

package/Base/managers/AbstractManager.d.ts

@@ -1,5 +1,5 @@
 /**
- * @typedef {import('../index.js').default} Base
+ * @typedef {import('../index.js').Base} Base
  * @typedef {import('../index.js').BaseConfig} BaseConfig
  * @typedef {import('./EventsManager.js').default} EventsManager
  */
@@ -39,6 +39,6 @@ export default class AbstractManager {
      */
     __hideProperties(properties: string[]): void;
 }
-export type Base = import('../index.js').default;
+export type Base = import('../index.js').Base;
 export type BaseConfig = import('../index.js').BaseConfig;
 export type EventsManager = import('./EventsManager.js').default;

package/Base/managers/ChildrenManager.cjs

@@ -27,7 +27,7 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 
-// packages/js-toolkit/Base/managers/ChildrenManager.js
+// packages/js-toolkit/Base/managers/ChildrenManager.ts
 var ChildrenManager_exports = {};
 __export(ChildrenManager_exports, {
   default: () => ChildrenManager
@@ -36,9 +36,7 @@ module.exports = __toCommonJS(ChildrenManager_exports);
 var import_AbstractManager = __toESM(require("./AbstractManager.cjs"), 1);
 var import_utils = require("../utils.cjs");
 function __getChild(that, el, ComponentClass, name) {
-  const asyncComponentPromise = that.__asyncComponentPromises.get(
-    ComponentClass
-  );
+  const asyncComponentPromise = that.__asyncComponentPromises.get(ComponentClass);
   if ("$isBase" in ComponentClass || asyncComponentPromise && asyncComponentPromise.status === "resolved") {
     let ctor = ComponentClass;
     if (asyncComponentPromise) {

package/Base/managers/ChildrenManager.d.ts

@@ -1,3 +1,5 @@
+import type { BaseConstructor, BaseAsyncConstructor } from '../index.js';
+import AbstractManager from './AbstractManager.js';
 /**
  * Children manager.
  */
@@ -5,17 +7,12 @@ export default class ChildrenManager extends AbstractManager {
     /**
      * Store async component promises to avoid calling them multiple times and
      * waiting for them when they are already resolved.
-     *
-     * @type {WeakMap<BaseAsyncConstructor, { promise: ReturnType<BaseAsyncConstructor>, status: 'pending'|'resolved', ctor?: BaseConstructor }>}
      */
     __asyncComponentPromises: WeakMap<BaseAsyncConstructor, {
         promise: ReturnType<BaseAsyncConstructor>;
         status: 'pending' | 'resolved';
         ctor?: BaseConstructor;
     }>;
-    /**
-     * @returns {string[]}
-     */
     get registeredNames(): string[];
     /**
      * Register instances of all children components.
@@ -34,8 +31,3 @@ export default class ChildrenManager extends AbstractManager {
      */
     destroyAll(): void;
 }
-export type Base = import('../index.js').default;
-export type BaseConstructor = import('../index.js').BaseConstructor;
-export type BaseAsyncConstructor = import('../index.js').BaseAsyncConstructor;
-export type BaseConfigComponents = import('../index.js').BaseConfigComponents;
-import AbstractManager from "./AbstractManager.js";

package/Base/managers/ChildrenManager.js

@@ -7,9 +7,7 @@ var __publicField = (obj, key, value) => {
 import AbstractManager from "./AbstractManager.js";
 import { getComponentElements } from "../utils.js";
 function __getChild(that, el, ComponentClass, name) {
-  const asyncComponentPromise = that.__asyncComponentPromises.get(
-    ComponentClass
-  );
+  const asyncComponentPromise = that.__asyncComponentPromises.get(ComponentClass);
   if ("$isBase" in ComponentClass || asyncComponentPromise && asyncComponentPromise.status === "resolved") {
     let ctor = ComponentClass;
     if (asyncComponentPromise) {

package/Base/managers/EventsManager.cjs

@@ -27,7 +27,7 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 
-// packages/js-toolkit/Base/managers/EventsManager.js
+// packages/js-toolkit/Base/managers/EventsManager.ts
 var EventsManager_exports = {};
 __export(EventsManager_exports, {
   default: () => EventsManager,
@@ -143,14 +143,14 @@ var EventsManager = class extends import_AbstractManager.default {
         const childrenManager = this.__base.$children;
         const { name, child: resolvedChild } = childrenManager.registeredNames.map((childName) => ({
           name: childName,
-          child: childrenManager[childName].find(
+          child: [...childrenManager[childName]].find(
             (instance) => instance === event.currentTarget || instance.$el === event.currentTarget
           )
         })).find(({ child }) => child);
         const normalizedChildName = normalizeName(name);
         const normalizedEventName = normalizeName(event.type);
         const method = `on${normalizedChildName}${normalizedEventName}`;
-        const index = childrenManager[name].indexOf(resolvedChild);
+        const index = [...childrenManager[name]].indexOf(resolvedChild);
         const args = (0, import_utils.isArray)(event.detail) ? event.detail : [];
         this.__base[method](...args, index, event);
       }

package/Base/managers/EventsManager.d.ts

@@ -1,3 +1,5 @@
+import type { Base } from '../index.js';
+import AbstractManager from './AbstractManager.js';
 /**
  * Normalize the given name to PascalCase, such as:
  *
@@ -18,42 +20,37 @@
  * @param {string} name
  * @returns {string}
  */
-export function normalizeName(name: string): string;
+export declare function normalizeName(name: string): string;
 /**
  * Normalize the event names from PascalCase to kebab-case.
  *
  * @param {string} name
  * @returns {string}
  */
-export function normalizeEventName(name: string): string;
+export declare function normalizeEventName(name: string): string;
 /**
  * Event management class.
  * @todo Prevent binding of `onChildOrRefEvent` to the root element
  * @todo Use event delegation?
  */
 export default class EventsManager extends AbstractManager {
-    /**
-     * @type {WeakMap}
-     */
-    __methodsCache: WeakMap<any, any>;
+    __methodsCache: Map<string, string[]>;
     /**
      * Event listener object for the root element.
-     *
-     * @type {EventListenerObject}
      */
     __rootElementHandler: EventListenerObject;
     /**
      * Event listener object for the refs.
-     *
-     * @type {EventListenerObject}
      */
     __refsHandler: EventListenerObject;
     /**
      * Event listener object for the children.
-     *
-     * @type {EventListenerObject}
      */
     __childrenHandler: EventListenerObject;
+    /**
+     * Class constructor.
+     */
+    constructor(base: Base);
     /**
      * Bind event methods to the given ref elements.
      *
@@ -107,6 +104,3 @@ export default class EventsManager extends AbstractManager {
      */
     unbindRootElement(): void;
 }
-export type Base = import('../index.js').default;
-export type ChildrenManager = import('./ChildrenManager.js').default;
-import AbstractManager from "./AbstractManager.js";

package/Base/managers/EventsManager.js

@@ -112,14 +112,14 @@ class EventsManager extends AbstractManager {
         const childrenManager = this.__base.$children;
         const { name, child: resolvedChild } = childrenManager.registeredNames.map((childName) => ({
           name: childName,
-          child: childrenManager[childName].find(
+          child: [...childrenManager[childName]].find(
             (instance) => instance === event.currentTarget || instance.$el === event.currentTarget
           )
         })).find(({ child }) => child);
         const normalizedChildName = normalizeName(name);
         const normalizedEventName = normalizeName(event.type);
         const method = `on${normalizedChildName}${normalizedEventName}`;
-        const index = childrenManager[name].indexOf(resolvedChild);
+        const index = [...childrenManager[name]].indexOf(resolvedChild);
         const args = isArray(event.detail) ? event.detail : [];
         this.__base[method](...args, index, event);
       }

package/Base/managers/OptionsManager.d.ts

@@ -52,7 +52,7 @@ export default class OptionsManager extends AbstractManager {
     set(name: string, value: any, config: OptionObject): void;
 }
 export type DeepmergeOptions = import('deepmerge').Options;
-export type Base = import('../index.js').default;
+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 = {
@@ -79,7 +79,7 @@ export type BooleanOption = {
 };
 export type OptionObject = ArrayOption | ObjectOption | StringOption | NumberOption | BooleanOption;
 export type OptionsSchema = {
-    [name: string]: OptionType | OptionObject;
+    [name: string]: OptionObject | OptionType;
 };
 export type OptionsInterface = {
     [optionName: string]: any;

package/Base/managers/ServicesManager.d.ts

@@ -79,7 +79,7 @@ export default class ServicesManager extends AbstractManager {
      */
     unregister(name: string): void;
 }
-export type Base = import('../index').default;
+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>>;

package/Base/types.d.ts

@@ -1,4 +1,5 @@
-import { KeyServiceProps, LoadServiceProps, PointerServiceProps, RafServiceProps, ResizeServiceProps, ScrollServiceProps } from '../services/index.js';
+import type { Base, BaseTypeParameter } from './index.js';
+import type { KeyServiceProps, LoadServiceProps, PointerServiceProps, RafServiceProps, ResizeServiceProps, ScrollServiceProps } from '../services/index.js';
 export interface BaseInterface {
     /**
      * Mounted hook.
@@ -41,3 +42,6 @@ export interface BaseInterface {
      */
     scrolled?(props: ScrollServiceProps): void;
 }
+export declare type BaseDecorator<S extends BaseInterface, T extends Base> = {
+    new <W extends BaseTypeParameter = BaseTypeParameter>(...args: unknown[]): S & T & Base<W>;
+} & Partial<Pick<T, keyof T>>;

package/Base/utils.cjs

@@ -16,7 +16,7 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// packages/js-toolkit/Base/utils.js
+// packages/js-toolkit/Base/utils.ts
 var utils_exports = {};
 __export(utils_exports, {
   eventIsDefinedInConfig: () => eventIsDefinedInConfig,

package/Base/utils.d.ts

@@ -1,6 +1,4 @@
-/**
- * @typedef {import('./index.js').default} Base
- */
+import type { Base, BaseConfig } from './index.js';
 /**
  * Get a list of elements based on the name of a component.
  *
@@ -11,30 +9,16 @@
  * @returns {Array<HTMLElement>}
  *   A list of elements on which the component should be mounted.
  */
-export function getComponentElements(nameOrSelector: string, element?: HTMLElement | Document): Array<HTMLElement>;
+export declare function getComponentElements(nameOrSelector: string, element?: HTMLElement | Document): HTMLElement[];
 /**
  * Test if an event is defined in the given config.
- *
- * @param   {string} event
- * @param   {import('./index.js').BaseConfig} config
- * @returns {boolean}
  */
-export function eventIsDefinedInConfig(event: string, config: import('./index.js').BaseConfig): boolean;
+export declare function eventIsDefinedInConfig(event: string, config: BaseConfig): boolean;
 /**
  * Test if an event can be used on the given element.
- *
- * @param   {string} event
- * @param   {HTMLElement} element
- * @returns {boolean}
  */
-export function eventIsNative(event: string, element: HTMLElement): boolean;
+export declare function eventIsNative(event: string, element: HTMLElement): boolean;
 /**
  * Get the target of a given event.
- *
- * @param   {Base} instance
- * @param   {string} event
- * @param   {import('./index.js').BaseConfig} config
- * @returns {Base|Base['$el']}
  */
-export function getEventTarget(instance: Base, event: string, config: import('./index.js').BaseConfig): Base | Base['$el'];
-export type Base = import('./index.js').default;
+export declare function getEventTarget(instance: Base, event: string, config: BaseConfig): Base | Base['$el'];

package/decorators/index.cjs

@@ -1,13 +1,7 @@
-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)
-    __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))
@@ -16,35 +10,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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // packages/js-toolkit/decorators/index.ts
 var decorators_exports = {};
-__export(decorators_exports, {
-  withBreakpointManager: () => import_withBreakpointManager.default,
-  withBreakpointObserver: () => import_withBreakpointObserver.default,
-  withDrag: () => import_withDrag.default,
-  withExtraConfig: () => import_withExtraConfig.default,
-  withFreezedOptions: () => import_withFreezedOptions.default,
-  withIntersectionObserver: () => import_withIntersectionObserver.default,
-  withMountWhenInView: () => import_withMountWhenInView.default,
-  withResponsiveOptions: () => import_withResponsiveOptions.default,
-  withScrolledInView: () => import_withScrolledInView.default,
-  withVue2: () => import_withVue2.default
-});
 module.exports = __toCommonJS(decorators_exports);
-var import_withBreakpointManager = __toESM(require("./withBreakpointManager.cjs"), 1);
-var import_withBreakpointObserver = __toESM(require("./withBreakpointObserver.cjs"), 1);
-var import_withDrag = __toESM(require("./withDrag.cjs"), 1);
-var import_withExtraConfig = __toESM(require("./withExtraConfig.cjs"), 1);
-var import_withFreezedOptions = __toESM(require("./withFreezedOptions.cjs"), 1);
-var import_withIntersectionObserver = __toESM(require("./withIntersectionObserver.cjs"), 1);
-var import_withMountWhenInView = __toESM(require("./withMountWhenInView.cjs"), 1);
-var import_withResponsiveOptions = __toESM(require("./withResponsiveOptions.cjs"), 1);
-var import_withScrolledInView = __toESM(require("./withScrolledInView.cjs"), 1);
-var import_withVue2 = __toESM(require("./withVue2.cjs"), 1);
+__reExport(decorators_exports, require("./withBreakpointManager.cjs"), module.exports);
+__reExport(decorators_exports, require("./withBreakpointObserver.cjs"), module.exports);
+__reExport(decorators_exports, require("./withDrag.cjs"), module.exports);
+__reExport(decorators_exports, require("./withExtraConfig.cjs"), module.exports);
+__reExport(decorators_exports, require("./withFreezedOptions.cjs"), module.exports);
+__reExport(decorators_exports, require("./withIntersectionObserver.cjs"), module.exports);
+__reExport(decorators_exports, require("./withMountWhenInView.cjs"), module.exports);
+__reExport(decorators_exports, require("./withResponsiveOptions.cjs"), module.exports);
+__reExport(decorators_exports, require("./withScrolledInView.cjs"), module.exports);
+__reExport(decorators_exports, require("./withVue2.cjs"), module.exports);
 if (module.exports.default) module.exports = module.exports.default;

package/decorators/index.d.ts

@@ -1,10 +1,10 @@
-export { default as withBreakpointManager } from './withBreakpointManager.js';
-export { default as withBreakpointObserver } from './withBreakpointObserver.js';
-export { default as withDrag } from './withDrag.js';
-export { default as withExtraConfig } from './withExtraConfig.js';
-export { default as withFreezedOptions } from './withFreezedOptions.js';
-export { default as withIntersectionObserver } from './withIntersectionObserver.js';
-export { default as withMountWhenInView } from './withMountWhenInView.js';
-export { default as withResponsiveOptions } from './withResponsiveOptions.js';
-export { default as withScrolledInView } from './withScrolledInView.js';
-export { default as withVue2 } from './withVue2.js';
+export * from './withBreakpointManager.js';
+export * from './withBreakpointObserver.js';
+export * from './withDrag.js';
+export * from './withExtraConfig.js';
+export * from './withFreezedOptions.js';
+export * from './withIntersectionObserver.js';
+export * from './withMountWhenInView.js';
+export * from './withResponsiveOptions.js';
+export * from './withScrolledInView.js';
+export * from './withVue2.js';

package/decorators/index.js

@@ -1,22 +1,10 @@
-import { default as default2 } from "./withBreakpointManager.js";
-import { default as default3 } from "./withBreakpointObserver.js";
-import { default as default4 } from "./withDrag.js";
-import { default as default5 } from "./withExtraConfig.js";
-import { default as default6 } from "./withFreezedOptions.js";
-import { default as default7 } from "./withIntersectionObserver.js";
-import { default as default8 } from "./withMountWhenInView.js";
-import { default as default9 } from "./withResponsiveOptions.js";
-import { default as default10 } from "./withScrolledInView.js";
-import { default as default11 } from "./withVue2.js";
-export {
-  default2 as withBreakpointManager,
-  default3 as withBreakpointObserver,
-  default4 as withDrag,
-  default5 as withExtraConfig,
-  default6 as withFreezedOptions,
-  default7 as withIntersectionObserver,
-  default8 as withMountWhenInView,
-  default9 as withResponsiveOptions,
-  default10 as withScrolledInView,
-  default11 as withVue2
-};
+export * from "./withBreakpointManager.js";
+export * from "./withBreakpointObserver.js";
+export * from "./withDrag.js";
+export * from "./withExtraConfig.js";
+export * from "./withFreezedOptions.js";
+export * from "./withIntersectionObserver.js";
+export * from "./withMountWhenInView.js";
+export * from "./withResponsiveOptions.js";
+export * from "./withScrolledInView.js";
+export * from "./withVue2.js";

package/decorators/withBreakpointManager.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,22 +14,18 @@ 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/decorators/withBreakpointManager.ts
 var withBreakpointManager_exports = {};
 __export(withBreakpointManager_exports, {
-  default: () => withBreakpointManager
+  withBreakpointManager: () => withBreakpointManager
 });
 module.exports = __toCommonJS(withBreakpointManager_exports);
-var import_resize = __toESM(require("../services/resize.cjs"), 1);
+var import_services = require("../services/index.cjs");
 var import_utils = require("../utils/index.cjs");
 function testBreakpoints(breakpoints) {
-  const { breakpoint } = (0, import_resize.default)().props();
+  const { breakpoint } = (0, import_services.useResize)().props();
   breakpoints.forEach(([breakpointKeys, instance]) => {
     if (breakpointKeys.includes(breakpoint) && !instance.$isMounted) {
       setTimeout(() => instance.$mount(), 0);
@@ -44,7 +38,7 @@ function mountComponents(instance, breakpoints) {
   return breakpoints.map(([bk, ComponentClass]) => {
     const child = new ComponentClass(instance.$el);
     Object.defineProperty(child, "$parent", { get: () => instance.$parent });
-    return [bk, child];
+    return [bk.split(" "), child];
   });
 }
 var instances = /* @__PURE__ */ new WeakMap();
@@ -61,14 +55,14 @@ function withBreakpointManager(BaseClass, breakpoints) {
     }
     return BaseClass;
   }
-  const { add, props } = (0, import_resize.default)();
+  const { add, props } = (0, import_services.useResize)();
   if (!props().breakpoint) {
     if (import_utils.isDev) {
-      throw new Error(`The \`BreakpointManager\` class requires breakpoints to be defined.`);
+      throw new Error("The `BreakpointManager` class requires breakpoints to be defined.");
     }
     return BaseClass;
   }
-  return class WithBreakpointManager extends BaseClass {
+  class WithBreakpointManager extends BaseClass {
     constructor(element) {
       super(element);
       if (!instances.has(this)) {
@@ -91,6 +85,7 @@ function withBreakpointManager(BaseClass, breakpoints) {
       }
       return super.$destroy();
     }
-  };
+  }
+  return WithBreakpointManager;
 }
 if (module.exports.default) module.exports = module.exports.default;

package/decorators/withBreakpointManager.d.ts

@@ -1,59 +1,6 @@
-import type Base from '../Base/index.js';
-import type { BaseConstructor, BaseTypeParameter } from '../Base/index.js';
+import type { BaseDecorator, BaseInterface } from '../Base/types.js';
+import type { Base, BaseConstructor } from '../Base/index.js';
 /**
  * BreakpointManager class.
  */
-export default function withBreakpointManager<T extends BaseTypeParameter = BaseTypeParameter>(BaseClass: BaseConstructor, breakpoints: Array<[string, BaseConstructor]>): typeof Base | {
-    new <U extends BaseTypeParameter = BaseTypeParameter>(element: any): {
-        /**
-         * Override the default $mount method to prevent component's from being
-         * mounted when they should not.
-         *
-         * @returns {this}
-         */
-        $mount(): any;
-        /**
-         * Destroy all instances when the main one is destroyed.
-         *
-         * @returns {this}
-         */
-        $destroy(): any;
-        $parent: Base<BaseTypeParameter>;
-        $id: string;
-        $el: (T & U)["$el"] & HTMLElement & {
-            __base__?: WeakMap<typeof Base, Base<BaseTypeParameter> | "terminated">;
-        };
-        $isMounted: boolean;
-        __eventHandlers: Map<string, Set<EventListenerOrEventListenerObject>>;
-        readonly $root: Base<BaseTypeParameter>;
-        readonly __config: import("../Base/index.js").BaseConfig;
-        __services: import("../Base/managers/ServicesManager.js").default;
-        readonly $services: import("../Base/managers/ServicesManager.js").default;
-        __refs: import("../Base/managers/RefsManager.js").default & (T & U)["$refs"] & import("../Base/index.js").BaseRefs;
-        readonly $refs: import("../Base/managers/RefsManager.js").default & (T & U)["$refs"] & import("../Base/index.js").BaseRefs;
-        __options: import("../Base/managers/OptionsManager.js").default & (T & U)["$options"] & import("../Base/index.js").BaseOptions;
-        readonly $options: import("../Base/managers/OptionsManager.js").default & (T & U)["$options"] & import("../Base/index.js").BaseOptions;
-        __children: import("../Base/managers/ChildrenManager.js").default & ((T & U)["$children"] extends infer T_1 ? { [key in keyof T_1]: (T & U)["$children"][key][]; } : never) & import("../Base/index.js").BaseChildren;
-        readonly $children: import("../Base/managers/ChildrenManager.js").default & ((T & U)["$children"] extends infer T_2 ? { [key_1 in keyof T_2]: (T & U)["$children"][key_1][]; } : never) & import("../Base/index.js").BaseChildren;
-        __events: import("../Base/managers/EventsManager.js").default;
-        readonly $log: (...args: any) => void;
-        readonly __debug: (...args: any) => void;
-        readonly __managers: import("../Base/index.js").Managers;
-        __callMethod(method: string, ...args: unknown[]): unknown;
-        __hasEvent(event: string): boolean;
-        $update(): any;
-        $terminate(): void;
-        __addEmits(event: string): void;
-        __removeEmits(event: string): void;
-        readonly __ctor: typeof Base;
-        $on(event: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): () => void;
-        $off(event: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
-        $emit(event: string, ...args: unknown[]): void;
-        addEventListener(type: string, callback: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
-        dispatchEvent(event: Event): boolean;
-        removeEventListener(type: string, callback: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
-    };
-    readonly $isBase: true;
-    config: import("../Base/index.js").BaseConfig;
-    $factory(nameOrSelector: string): Base<BaseTypeParameter>[];
-};
+export declare function withBreakpointManager<S extends Base>(BaseClass: typeof Base, breakpoints: Array<[string, BaseConstructor<Base>]>): BaseDecorator<BaseInterface, S>;