@studiometa/js-toolkit 2.4.2 → 2.4.4-alpha.1

package/Base/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * @typedef {typeof Base} BaseConstructor
  * @typedef {(Base) => Promise<BaseConstructor | { default: BaseConstructor }>} BaseAsyncConstructor
- * @typedef {OptionsManager & { [name:string]: any }} BaseOptions
+ * @typedef {{ [name:string]: any }} BaseOptions
  * @typedef {{ [name:string]: HTMLElement | HTMLElement[] }} BaseRefs
  * @typedef {{ [nameOrSelector:string]: Base[] | Promise<Base>[] }} BaseChildren
  * @typedef {{ [nameOrSelector:string]: BaseConstructor | BaseAsyncConstructor }} BaseConfigComponents
@@ -18,6 +18,14 @@
  * @property {BaseConfigComponents} [components]
  * @property {BaseConfigOptions} [options]
  */
+/**
+ * @typedef {{
+ *   $el?: HTMLElement,
+ *   $options?: BaseOptions,
+ *   $refs?: BaseRefs,
+ *   $children?: { [name:string]: Base | Promise<Base> },
+ * }} BaseTypeParameter
+ */
 /**
  * @typedef {Object} Managers
  * @property {typeof ChildrenManager} ChildrenManager
@@ -28,12 +36,15 @@
  */
 /**
  * Base class.
- * @template {{ $options: BaseOptions, $refs: BaseRefs, $children: BaseChildren }} BaseInterface
+ * @template {BaseTypeParameter} [BaseInterface={ $el: HTMLElement, $options: BaseOptions, $refs: BaseRefs, $children: { [name:string]: Base | Promise<Base> } }]
  */
-export default class Base<BaseInterface extends {
+export default class Base<BaseInterface extends BaseTypeParameter = {
+    $el: HTMLElement;
     $options: BaseOptions;
     $refs: BaseRefs;
-    $children: BaseChildren;
+    $children: {
+        [name: string]: Base<any> | Promise<Base<any>>;
+    };
 }> extends EventTarget {
     /**
      * This is a Base instance.
@@ -51,7 +62,7 @@ export default class Base<BaseInterface extends {
      * @param  {string}      nameOrSelector The selector on which to mount each instance.
      * @returns {Array<Base>}                A list of the created instance.
      */
-    static $factory(nameOrSelector: string): Array<Base<any>>;
+    static $factory(nameOrSelector: string): Array<Base>;
     /**
      * Class constructor where all the magic takes place.
      *
@@ -62,7 +73,7 @@ export default class Base<BaseInterface extends {
      * The instance parent.
      * @type {Base}
      */
-    $parent: Base<any>;
+    $parent: Base;
     /**
      * The instance id.
      * @type {string}
@@ -70,10 +81,10 @@ export default class Base<BaseInterface extends {
     $id: string;
     /**
      * The root element.
-     * @type {HTMLElement & { __base__?: WeakMap<BaseConstructor, Base | 'terminated'> }}
+     * @type {BaseInterface['$el'] & HTMLElement & { __base__?: WeakMap<BaseConstructor, Base | 'terminated'> }}
      */
-    $el: HTMLElement & {
-        __base__?: WeakMap<BaseConstructor, Base<any> | 'terminated'>;
+    $el: BaseInterface['$el'] & HTMLElement & {
+        __base__?: WeakMap<BaseConstructor, Base | 'terminated'>;
     };
     /**
      * The state of the component.
@@ -83,65 +94,63 @@ export default class Base<BaseInterface extends {
     /**
      * Store the event handlers.
      *
-     * @private
      * @type {Map<string, Set<EventListenerOrEventListenerObject>>}
      */
-    private __eventHandlers;
+    __eventHandlers: Map<string, Set<EventListenerOrEventListenerObject>>;
     /**
      * Get the root instance of the app.
      * @returns {Base}
      */
-    get $root(): Base<any>;
+    get $root(): Base<{
+        $el: HTMLElement;
+        $options: BaseOptions;
+        $refs: BaseRefs;
+        $children: {
+            [name: string]: Base<any> | Promise<Base<any>>;
+        };
+    }>;
     /**
      * Merge configuration with the parents' configurations.
      *
      * @returns {BaseConfig}
-     * @private
      */
-    private get __config();
+    get __config(): BaseConfig;
     /**
      * @type {ServicesManager}
-     * @private
      */
-    private __services;
+    __services: ServicesManager;
     /**
      * @type {ServicesManager}
      */
     get $services(): ServicesManager;
     /**
-     * @type {RefsManager & { [key in keyof BaseInterface['$refs']]: BaseInterface['$refs'][key] }}
-     * @private
+     * @type {RefsManager & BaseInterface['$refs'] & BaseRefs}
      */
-    private __refs;
+    __refs: RefsManager & BaseInterface['$refs'] & BaseRefs;
     /**
-     * @returns {RefsManager & { [key in keyof BaseInterface['$refs']]: BaseInterface['$refs'][key] }}
+     * @returns {RefsManager & BaseInterface['$refs'] & BaseRefs}
      */
-    get $refs(): RefsManager & (BaseInterface["$refs"] extends infer T ? { [key in keyof T]: BaseInterface["$refs"][key]; } : never);
+    get $refs(): RefsManager & BaseInterface["$refs"] & BaseRefs;
     /**
-     * @type {BaseOptions & { [key in keyof BaseInterface['$options']]: BaseInterface['$options'][key] }}
-     * @private
+     * @type {OptionsManager & BaseInterface['$options'] & BaseOptions}
      */
-    private __options;
+    __options: OptionsManager & BaseInterface['$options'] & BaseOptions;
     /**
-     * @returns {BaseOptions & { [key in keyof BaseInterface['$options']]: BaseInterface['$options'][key] }}
+     * @returns {OptionsManager & BaseInterface['$options'] & BaseOptions}
      */
-    get $options(): OptionsManager & {
-        [name: string]: any;
-    } & (BaseInterface["$options"] extends infer T_1 ? { [key_1 in keyof T_1]: BaseInterface["$options"][key_1]; } : never);
+    get $options(): OptionsManager & BaseInterface["$options"] & BaseOptions;
     /**
-     * @type {ChildrenManager & { [key in keyof BaseInterface['$children']]: Array<BaseInterface['$children'][key]> }}
-     * @private
+     * @type {ChildrenManager & { [key in keyof BaseInterface['$children']]: Array<BaseInterface['$children'][key]> } & BaseChildren}
      */
-    private __children;
+    __children: ChildrenManager & (BaseInterface["$children"] extends infer T ? { [key in keyof T]: BaseInterface["$children"][key][]; } : never) & BaseChildren;
     /**
-     * @returns {ChildrenManager & { [key in keyof BaseInterface['$children']]: Array<BaseInterface['$children'][key]> }}
+     * @returns {ChildrenManager & { [key in keyof BaseInterface['$children']]: Array<BaseInterface['$children'][key]> } & BaseChildren}
      */
-    get $children(): ChildrenManager & (BaseInterface["$children"] extends infer T_2 ? { [key_2 in keyof T_2]: BaseInterface["$children"][key_2][]; } : never);
+    get $children(): ChildrenManager & (BaseInterface["$children"] extends infer T_1 ? { [key_1 in keyof T_1]: BaseInterface["$children"][key_1][]; } : never) & BaseChildren;
     /**
      * @type {EventsManager}
-     * @private
      */
-    private __events;
+    __events: EventsManager;
     /**
      * Small helper to log stuff.
      *
@@ -151,10 +160,9 @@ export default class Base<BaseInterface extends {
     /**
      * Small helper to debug information.
      *
-     * @private
      * @returns {(...args:any) => void}
      */
-    private get __debug();
+    get __debug(): (...args: any) => void;
     /**
      * Get manager constructors.
      *
@@ -164,20 +172,18 @@ export default class Base<BaseInterface extends {
     /**
      * Call an instance method and emit corresponding events.
      *
-     * @private
      * @param {string} method
      * @param {any[]} args
      * @returns {any}
      */
-    private __callMethod;
+    __callMethod(method: string, ...args: any[]): any;
     /**
      * Test if the given event has been bound to the instance.
      *
-     * @private
      * @param  {string} event The event's name.
      * @returns {boolean}      Wether the given event has been bound or not.
      */
-    private __hasEvent;
+    __hasEvent(event: string): boolean;
     /**
      * Trigger the `mounted` callback.
      * @returns {this}
@@ -201,26 +207,23 @@ export default class Base<BaseInterface extends {
     /**
      * Add an emitted event.
      *
-     * @private
      * @param   {string} event The event name.
      * @returns {void}
      */
-    private __addEmits;
+    __addEmits(event: string): void;
     /**
      * Remove an emitted event.
      *
-     * @private
      * @param   {string} event The event name.
      * @returns {void}
      */
-    private __removeEmits;
+    __removeEmits(event: string): void;
     /**
      * Get the instance constructor.
      *
-     * @private
      * @returns {BaseConstructor}
      */
-    private get __ctor();
+    get __ctor(): typeof Base;
     /**
      * Bind a listener function to an event.
      *
@@ -260,13 +263,29 @@ export type BaseConstructor = typeof Base;
 export type BaseAsyncConstructor = (Base: any) => Promise<BaseConstructor | {
     default: BaseConstructor;
 }>;
-export type BaseOptions = OptionsManager & {
+export type BaseOptions = {
     [name: string]: any;
 };
 export type BaseRefs = {
     [name: string]: HTMLElement | HTMLElement[];
 };
-export type BaseChildren = BaseChildren;
+export type BaseChildren = {
+    [nameOrSelector: string]: Base<{
+        $el: HTMLElement;
+        $options: BaseOptions;
+        $refs: BaseRefs;
+        $children: {
+            [name: string]: Base<any> | Promise<Base<any>>;
+        };
+    }>[] | Promise<Base<{
+        $el: HTMLElement;
+        $options: BaseOptions;
+        $refs: BaseRefs;
+        $children: {
+            [name: string]: Base<any> | Promise<Base<any>>;
+        };
+    }>>[];
+};
 export type BaseConfigComponents = {
     [nameOrSelector: string]: typeof Base | BaseAsyncConstructor;
 };
@@ -281,6 +300,28 @@ export type BaseConfig = {
     components?: BaseConfigComponents;
     options?: BaseConfigOptions;
 };
+export type BaseTypeParameter = {
+    $el?: HTMLElement;
+    $options?: BaseOptions;
+    $refs?: BaseRefs;
+    $children?: {
+        [name: string]: Base<{
+            $el: HTMLElement;
+            $options: BaseOptions;
+            $refs: BaseRefs;
+            $children: {
+                [name: string]: Base<any> | Promise<Base<any>>;
+            };
+        }> | Promise<Base<{
+            $el: HTMLElement;
+            $options: BaseOptions;
+            $refs: BaseRefs;
+            $children: {
+                [name: string]: Base<any> | Promise<Base<any>>;
+            };
+        }>>;
+    };
+};
 export type Managers = {
     ChildrenManager: typeof ChildrenManager;
     EventsManager: typeof EventsManager;

package/Base/managers/AbstractManager.d.ts

@@ -12,11 +12,11 @@ export default class AbstractManager {
      *
      * @param   {Base} base
      */
-    constructor(base: import("../index.js").default<any>);
+    constructor(base: Base);
     /**
      * @type {Base}
      */
-    __base: import("../index.js").default<any>;
+    __base: Base;
     /**
      * Get the base instance root element.
      * @returns {HTMLElement}
@@ -39,6 +39,6 @@ export default class AbstractManager {
      */
     __hideProperties(properties: string[]): void;
 }
-export type Base = import("../index.js").default<any>;
+export type Base = import('../index.js').default;
 export type BaseConfig = import('../index.js').BaseConfig;
 export type EventsManager = import('./EventsManager.js').default;

package/Base/managers/ChildrenManager.d.ts

@@ -34,7 +34,7 @@ export default class ChildrenManager extends AbstractManager {
      */
     destroyAll(): void;
 }
-export type Base = import("../index.js").default<any>;
+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;

package/Base/managers/EventsManager.d.ts

@@ -83,7 +83,7 @@ export default class EventsManager extends AbstractManager {
      *   A base instance.
      * @returns {void}
      */
-    bindChild(name: string, instance: import("../index.js").default<any>): void;
+    bindChild(name: string, instance: Base): void;
     /**
      * Unbind event methods to the given child instance.
      *
@@ -93,7 +93,7 @@ export default class EventsManager extends AbstractManager {
      *   A base instance.
      * @returns {void}
      */
-    unbindChild(name: string, instance: import("../index.js").default<any>): void;
+    unbindChild(name: string, instance: Base): void;
     /**
      * Bind event methods on the root element.
      *
@@ -107,6 +107,6 @@ export default class EventsManager extends AbstractManager {
      */
     unbindRootElement(): void;
 }
-export type Base = import("../index.js").default<any>;
+export type Base = import('../index.js').default;
 export type ChildrenManager = import('./ChildrenManager.js').default;
 import AbstractManager from "./AbstractManager.js";

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<any>;
+export type Base = import('../index.js').default;
 export type BaseConfig = import('../index.js').BaseConfig;
 export type OptionType = StringConstructor | NumberConstructor | BooleanConstructor | ArrayConstructor | ObjectConstructor;
 export type ArrayOption = {

package/Base/managers/ResponsiveOptionsManager.cjs

@@ -22,7 +22,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// packages/js-toolkit/Base/managers/ResponsiveOptionsManager.js
+// packages/js-toolkit/Base/managers/ResponsiveOptionsManager.ts
 var ResponsiveOptionsManager_exports = {};
 __export(ResponsiveOptionsManager_exports, {
   default: () => ResponsiveOptionsManager

package/Base/managers/ResponsiveOptionsManager.d.ts

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

package/Base/managers/ServicesManager.d.ts

@@ -11,11 +11,11 @@ export default class ServicesManager extends AbstractManager {
     /**
      * @type {Record<string, () => ServiceInterface>}
      */
-    __customServices: Record<string, () => ServiceInterface>;
+    __customServices: Record<string, () => import("../../services").ServiceInterface<any>>;
     /**
      * @returns {Record<string, () => ServiceInterface>}
      */
-    get __services(): Record<string, () => ServiceInterface>;
+    get __services(): Record<string, () => import("../../services").ServiceInterface<any>>;
     /**
      * Test if the given service is registered.
      *
@@ -28,7 +28,7 @@ export default class ServicesManager extends AbstractManager {
      * @param   {ServiceName} service The name of the service.
      * @returns {ReturnType<ServiceInterface['props']>}
      */
-    get(service: ServiceName): ReturnType<ServiceInterface['props']>;
+    get(service: ServiceName): ReturnType<import("../../services").ServiceInterface<any>['props']>;
     /**
      * Init the given service and bind it to the given instance.
      *
@@ -70,7 +70,7 @@ export default class ServicesManager extends AbstractManager {
      * @param {() => ServiceInterface} useFunction
      *   The `use...` function for the service.
      */
-    register(name: string, useFunction: () => ServiceInterface): void;
+    register(name: string, useFunction: () => import("../../services").ServiceInterface<any>): void;
     /**
      * Unregister a new service to be enabled disabled.
      *
@@ -79,10 +79,10 @@ export default class ServicesManager extends AbstractManager {
      */
     unregister(name: string): void;
 }
-export type Base = import("../index").default<any>;
+export type Base = import('../index').default;
 export type BaseConstructor = import('../index').BaseConstructor;
 export type ServiceInterface = import('../../services').ServiceInterface<any>;
-export type Services = typeof SERVICES_MAP & Record<string, () => ServiceInterface>;
+export type Services = typeof SERVICES_MAP & Record<string, () => import("../../services").ServiceInterface<any>>;
 export type ServiceName = keyof {
     scrolled: typeof useScroll;
     resized: typeof useResize;

package/Base/utils.d.ts

@@ -36,5 +36,5 @@ export function eventIsNative(event: string, element: HTMLElement): boolean;
  * @param   {import('./index.js').BaseConfig} config
  * @returns {Base|Base['$el']}
  */
-export function getEventTarget(instance: import("./index.js").default<any>, event: string, config: import('./index.js').BaseConfig): import("./index.js").default<any> | import("./index.js").default<any>['$el'];
-export type Base = import("./index.js").default<any>;
+export function getEventTarget(instance: Base, event: string, config: import('./index.js').BaseConfig): Base | Base['$el'];
+export type Base = import('./index.js').default;

package/decorators/index.cjs

@@ -22,7 +22,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// packages/js-toolkit/decorators/index.js
+// packages/js-toolkit/decorators/index.ts
 var decorators_exports = {};
 __export(decorators_exports, {
   withBreakpointManager: () => import_withBreakpointManager.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 { 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';

package/decorators/withBreakpointManager.cjs

@@ -22,7 +22,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// packages/js-toolkit/decorators/withBreakpointManager.js
+// packages/js-toolkit/decorators/withBreakpointManager.ts
 var withBreakpointManager_exports = {};
 __export(withBreakpointManager_exports, {
   default: () => withBreakpointManager
@@ -68,7 +68,7 @@ function withBreakpointManager(BaseClass, breakpoints) {
     }
     return BaseClass;
   }
-  return class extends BaseClass {
+  return class WithBreakpointManager extends BaseClass {
     constructor(element) {
       super(element);
       if (!instances.has(this)) {
@@ -77,7 +77,6 @@ function withBreakpointManager(BaseClass, breakpoints) {
       add(`BreakpointManager-${this.$id}`, () => {
         testBreakpoints(instances.get(this));
       });
-      this.instances = instances.get(this);
     }
     $mount() {
       super.$mount();

package/decorators/withBreakpointManager.d.ts

@@ -1,10 +1,87 @@
+import type Base from '../Base/index.js';
+import type { BaseConstructor, BaseTypeParameter } from '../Base/index.js';
 /**
  * BreakpointManager class.
- * @template {BaseConstructor} T
- * @param {T} BaseClass
- * @param {Array<[string, BaseConstructor]>} breakpoints
- * @returns {T}
  */
-export default function withBreakpointManager<T extends typeof import("../Base").default>(BaseClass: T, breakpoints: Array<[string, BaseConstructor]>): T;
-export type Base = import("../Base").default<any>;
-export type BaseConstructor = import('../Base').BaseConstructor;
+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<{
+            $el: HTMLElement;
+            $options: import("../Base/index.js").BaseOptions;
+            $refs: import("../Base/index.js").BaseRefs;
+            $children: {
+                [name: string]: Base<any> | Promise<Base<any>>;
+            };
+        }>;
+        $id: string;
+        $el: (T & U)["$el"] & HTMLElement & {
+            __base__?: WeakMap<typeof Base, Base<{
+                $el: HTMLElement;
+                $options: import("../Base/index.js").BaseOptions;
+                $refs: import("../Base/index.js").BaseRefs;
+                $children: {
+                    [name: string]: Base<any> | Promise<Base<any>>;
+                };
+            }> | "terminated">;
+        };
+        $isMounted: boolean;
+        __eventHandlers: Map<string, Set<EventListenerOrEventListenerObject>>;
+        readonly $root: Base<{
+            $el: HTMLElement;
+            $options: import("../Base/index.js").BaseOptions;
+            $refs: import("../Base/index.js").BaseRefs;
+            $children: {
+                [name: string]: Base<any> | Promise<Base<any>>;
+            };
+        }>;
+        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: any[]): any;
+        __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: any[]): 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: boolean;
+    config: import("../Base/index.js").BaseConfig;
+    $factory(nameOrSelector: string): Base<{
+        $el: HTMLElement;
+        $options: import("../Base/index.js").BaseOptions;
+        $refs: import("../Base/index.js").BaseRefs;
+        $children: {
+            [name: string]: Base<any> | Promise<Base<any>>;
+        };
+    }>[];
+};

package/decorators/withBreakpointManager.js

@@ -38,7 +38,7 @@ function withBreakpointManager(BaseClass, breakpoints) {
     }
     return BaseClass;
   }
-  return class extends BaseClass {
+  return class WithBreakpointManager extends BaseClass {
     constructor(element) {
       super(element);
       if (!instances.has(this)) {
@@ -47,7 +47,6 @@ function withBreakpointManager(BaseClass, breakpoints) {
       add(`BreakpointManager-${this.$id}`, () => {
         testBreakpoints(instances.get(this));
       });
-      this.instances = instances.get(this);
     }
     $mount() {
       super.$mount();

package/decorators/withBreakpointObserver.cjs

@@ -27,7 +27,7 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 
-// packages/js-toolkit/decorators/withBreakpointObserver.js
+// packages/js-toolkit/decorators/withBreakpointObserver.ts
 var withBreakpointObserver_exports = {};
 __export(withBreakpointObserver_exports, {
   default: () => withBreakpointObserver
@@ -62,7 +62,7 @@ function addToResize(key, instance) {
   }
   const { add, has } = (0, import_resize.default)();
   if (!has(key)) {
-    add(key, function onResize({ breakpoint }) {
+    add(key, ({ breakpoint }) => {
       const action = testBreakpoints(instance, breakpoint);
       if (action === "$destroy" && instance.$isMounted) {
         instance[action]();