@studiometa/js-toolkit 2.4.1 → 2.4.4-alpha.0

package/Base/managers/ServicesManager.d.ts

@@ -1,109 +0,0 @@
-/**
- * @typedef {typeof SERVICES_MAP & Record<string, () => ServiceInterface>} Services
- * @typedef {keyof SERVICES_MAP|string} ServiceName
- */
-/**
- * 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 {
-    /**
-     * @type {Record<string, () => ServiceInterface>}
-     */
-    __customServices: Record<string, () => ServiceInterface>;
-    /**
-     * @returns {Record<string, () => ServiceInterface>}
-     */
-    get __services(): Record<string, () => ServiceInterface>;
-    /**
-     * Test if the given service is registered.
-     *
-     * @param  {ServiceName} service The name of the service.
-     * @returns {boolean}
-     */
-    has(service: ServiceName): boolean;
-    /**
-     * Get a service props by name.
-     * @param   {ServiceName} service The name of the service.
-     * @returns {ReturnType<ServiceInterface['props']>}
-     */
-    get(service: ServiceName): ReturnType<ServiceInterface['props']>;
-    /**
-     * Init the given service and bind it to the given instance.
-     *
-     * @param  {ServiceName} service The name of the service.
-     * @returns {() => void}          A function to unbind the service.
-     */
-    enable(service: ServiceName): () => void;
-    /**
-     * Enable all services and return methods to disable them.
-     *
-     * @returns {Function[]}
-     */
-    enableAll(): Function[];
-    /**
-     * Disable all services.
-     *
-     * @returns {void}
-     */
-    disableAll(): void;
-    /**
-     * Disable a service.
-     *
-     * @param  {string} service  The name of the service.
-     * @returns {void}
-     */
-    disable(service: string): 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;
-    /**
-     * Register a new service to be enabled/disabled.
-     *
-     * @param {string} name
-     *   The name of the service hook.
-     * @param {() => ServiceInterface} useFunction
-     *   The `use...` function for the service.
-     */
-    register(name: string, useFunction: () => ServiceInterface): void;
-    /**
-     * Unregister a new service to be enabled disabled.
-     *
-     * @param {string} name
-     *   The name of the service hook.
-     */
-    unregister(name: string): void;
-}
-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 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/utils.d.ts

@@ -1,40 +0,0 @@
-/**
- * @typedef {import('./index.js').default} Base
- */
-/**
- * Get a list of elements based on the name of a component.
- *
- * @param {string} nameOrSelector
- *   The name or selector to used for this component.
- * @param {HTMLElement|Document} element
- *   The root element on which to query the selector, defaults to `document`.
- * @returns {Array<HTMLElement>}
- *   A list of elements on which the component should be mounted.
- */
-export function getComponentElements(nameOrSelector: string, element?: HTMLElement | Document): Array<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;
-/**
- * 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;
-/**
- * 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;

package/decorators/index.d.ts

@@ -1,10 +0,0 @@
-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.d.ts

@@ -1,10 +0,0 @@
-/**
- * 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;
-export type BaseConstructor = import('../Base').BaseConstructor;

package/decorators/withBreakpointObserver.d.ts

@@ -1,17 +0,0 @@
-/**
- * BreakpointObserver class.
- *
- * @template {BaseConstructor} T
- * @param {T} BaseClass The Base class to extend from.
- * @returns {T}
- */
-export default function withBreakpointObserver<T extends typeof import("../Base").default>(BaseClass: T): T;
-export type Base = import('../Base').default;
-export type BaseConstructor = import('../Base').BaseConstructor;
-export type WithBreakpointObserverOptions = {
-    activeBreakpoints?: string;
-    inactiveBreakpoints?: string;
-};
-export type WithBreakpointObserverInterface = {
-    $options: WithBreakpointObserverOptions;
-};

package/decorators/withDrag.d.ts

@@ -1,23 +0,0 @@
-/**
- * @typedef {import('../Base').default} Base
- * @typedef {import('../Base').BaseConstructor} BaseConstructor
- * @typedef {import('../services/drag').DragServiceOptions} DragServiceOptions
- */
-/**
- * @typedef {DragServiceOptions & { target?: (this:Base, Base) => HTMLElement }} DragDecoratorOptions
- */
-/**
- * Add dragging capabilities to a component.
- *
- * @template {BaseConstructor} T
- * @param {T} BaseClass
- * @param {DragDecoratorOptions} options
- * @returns {T}
- */
-export default function withDrag<T extends typeof import("../Base").default>(BaseClass: T, { target, ...options }?: DragDecoratorOptions): T;
-export type Base = import('../Base').default;
-export type BaseConstructor = import('../Base').BaseConstructor;
-export type DragServiceOptions = import('../services/drag').DragServiceOptions;
-export type DragDecoratorOptions = import("../services/drag.js").DragServiceOptions & {
-    target?: (this: import("../Base").default, Base: any) => HTMLElement;
-};

package/decorators/withExtraConfig.d.ts

@@ -1,18 +0,0 @@
-/**
- * @typedef {import('deepmerge').Options} DeepmergeOptions
- * @typedef {import('../Base').BaseConfig} BaseConfig
- * @typedef {import('../Base').BaseConstructor} BaseConstructor
- */
-/**
- * Extends the configuration of an existing class.
- *
- * @template {BaseConstructor} T
- * @param {T} BaseClass The Base class to extend.
- * @param {Partial<BaseConfig>} config Extra configuration to merge.
- * @param {DeepmergeOptions} options Options for the `deepmerge` function. {@link https://github.com/TehShrike/deepmerge#options}
- * @returns {T}
- */
-export default function withExtraConfig<T extends typeof import("../Base").default>(BaseClass: T, config: Partial<BaseConfig>, options?: DeepmergeOptions): T;
-export type DeepmergeOptions = import('deepmerge').Options;
-export type BaseConfig = import('../Base').BaseConfig;
-export type BaseConstructor = import('../Base').BaseConstructor;

package/decorators/withFreezedOptions.d.ts

@@ -1,14 +0,0 @@
-/**
- * @typedef {import('../Base').BaseOptions} BaseOptions
- * @typedef {import('../Base').BaseConstructor} BaseConstructor
- */
-/**
- * Freeze the `$options` property to improve performance.
- *
- * @template {BaseConstructor} T
- * @param {T} BaseClass The Base class to extend.
- * @returns {T}
- */
-export default function withFreezedOptions<T extends typeof import("../Base").default>(BaseClass: T): T;
-export type BaseOptions = import('../Base').BaseOptions;
-export type BaseConstructor = import('../Base').BaseConstructor;

package/decorators/withIntersectionObserver.d.ts

@@ -1,23 +0,0 @@
-/**
- * IntersectionObserver decoration.
- *
- * @template {BaseConstructor} T
- * @param {T} BaseClass The Base class to extend.
- * @param {Object} [defaultOptions] The options for the IntersectionObserver instance.
- * @returns {T & { new: (element:HTMLElement) => { $observer: IntersectionObserver }}}
- */
-export default function withIntersectionObserver<T extends typeof import("../Base").default>(BaseClass: T, defaultOptions?: any): T & {
-    new: (element: HTMLElement) => {
-        $observer: IntersectionObserver;
-    };
-};
-export type Base = import('../Base').default;
-export type BaseConstructor = import('../Base').BaseConstructor;
-export type WithIntersectionObserverOptions = {
-    intersectionObserver: any;
-};
-export type WithIntersectionObserverInterface = {
-    $options: WithIntersectionObserverOptions;
-    $observer: IntersectionObserver;
-    intersected: (entries: IntersectionObserverEntry[]) => void;
-};

package/decorators/withMountWhenInView.d.ts

@@ -1,33 +0,0 @@
-/**
- * @typedef {import('../Base').default} Base
- * @typedef {import('../Base').BaseOptions} BaseOptions
- * @typedef {import('../Base').BaseConstructor} BaseConstructor
- */
-/**
- * @typedef {Object} WithMountWhenInViewOptions
- * @property {IntersectionObserverInit} intersectionObserver
- */
-/**
- * @typedef {Object} WithMountWhenInViewInterface
- * @property {() => void} terminated
- * @property {WithMountWhenInViewOptions & BaseOptions} $options
- */
-/**
- * IntersectionObserver decoration.
- *
- * @template {BaseConstructor} T
- * @param {T} BaseClass The Base class to extend.
- * @param {IntersectionObserverInit} [defaultOptions] The options for the IntersectionObserver instance.
- * @returns {T}
- */
-export default function withMountWhenInView<T extends typeof import("../Base").default>(BaseClass: T, defaultOptions?: IntersectionObserverInit): T;
-export type Base = import('../Base').default;
-export type BaseOptions = import('../Base').BaseOptions;
-export type BaseConstructor = import('../Base').BaseConstructor;
-export type WithMountWhenInViewOptions = {
-    intersectionObserver: IntersectionObserverInit;
-};
-export type WithMountWhenInViewInterface = {
-    terminated: () => void;
-    $options: WithMountWhenInViewOptions & BaseOptions;
-};

package/decorators/withResponsiveOptions.d.ts

@@ -1,8 +0,0 @@
-/**
- * Extends the configuration of an existing class.
- *
- * @template {import('../Base').BaseConstructor} T
- * @param {T} BaseClass The Base class to extend.
- * @returns {T}
- */
-export default function withResponsiveOptions<T extends typeof import("../Base").default>(BaseClass: T): T;

package/decorators/withScrolledInView.d.ts

@@ -1,19 +0,0 @@
-/**
- * @typedef {import('../Base').default} Base
- * @typedef {import('../Base').BaseConstructor} BaseConstructor
- * @typedef {import('../Base').BaseConfig} BaseConfig
- */
-/**
- * Add scrolled in view capabilities to a component.
- *
- * @template {BaseConstructor} T
- * @param {T} BaseClass
- * @param {IntersectionObserverInit & { useOffsetSizes?: boolean }} options
- * @returns {T}
- */
-export default function withScrolledInView<T extends typeof import("../Base").default>(BaseClass: T, options?: IntersectionObserverInit & {
-    useOffsetSizes?: boolean;
-}): T;
-export type Base = import('../Base').default;
-export type BaseConstructor = import('../Base').BaseConstructor;
-export type BaseConfig = import('../Base').BaseConfig;

package/decorators/withVue2.d.ts

@@ -1,7 +0,0 @@
-declare function _default<T extends typeof import("../Base").default>(BaseClass: T, Vue: import('vue').VueConstructor): T;
-export default _default;
-export type Base = import('../Base').default;
-export type BaseConstructor = import('../Base').BaseConstructor;
-export type WithVue2Refs = {
-    vue: HTMLElement;
-};

package/helpers/createApp.d.ts

@@ -1,14 +0,0 @@
-/**
- * @typedef {import('../Base/index.js').BaseConstructor} BaseConstructor
- */
-/**
- * Instantiate and mount the given component on the given root element when the page has been loaded
- * and return a function to use the app instance when it is ready.
- *
- * @template {BaseConstructor} T
- * @param {T} App
- * @param {HTMLElement} [rootElement]
- * @returns {() => Promise<InstanceType<T>>}
- */
-export default function createApp<T extends typeof import("../Base/index.js").default>(App: T, rootElement?: HTMLElement): () => Promise<InstanceType<T>>;
-export type BaseConstructor = import('../Base/index.js').BaseConstructor;

package/helpers/getDirectChildren.d.ts

@@ -1,24 +0,0 @@
-/**
- * @typedef {import('../Base/index.js').default} Base
- */
-/**
- * Get direct children from a parent when working with nested components.
- *
- * @template {Base} T
- * @param   {Base} parentInstance
- * @param   {string} parentName
- * @param   {string} childrenName
- * @returns {Array<T>}
- */
-export function getDirectChildren<T extends import("../Base/index.js").default>(parentInstance: Base, parentName: string, childrenName: string): T[];
-/**
- * Test if a component instance is a direct child from the given component.
- *
- * @param   {Base}    parentInstance
- * @param   {string}  parentName
- * @param   {string}  childrenName
- * @param   {Base}    childInstance
- * @returns {boolean}
- */
-export function isDirectChild(parentInstance: Base, parentName: string, childrenName: string, childInstance: Base): boolean;
-export type Base = import('../Base/index.js').default;

package/helpers/getInstanceFromElement.d.ts

@@ -1,14 +0,0 @@
-/**
- * @typedef {import('../Base/index.js').BaseConstructor} BaseConstructor
- */
-/**
- * Get a component instance from a DOM element.
- * @template {BaseConstructor} T
- * @param    {HTMLElement & { __base__?: WeakMap<T, InstanceType<T>> }} element
- * @param    {T} Constructor
- * @returns  {null|InstanceType<T>}
- */
-export default function getInstanceFromElement<T extends typeof import("../Base/index.js").default>(element: HTMLElement & {
-    __base__?: WeakMap<T, InstanceType<T>>;
-}, Constructor: T): InstanceType<T>;
-export type BaseConstructor = import('../Base/index.js').BaseConstructor;

package/helpers/importOnInteraction.d.ts

@@ -1,23 +0,0 @@
-/**
- * @typedef {import('../Base/index.js').BaseConstructor} BaseConstructor
- * @typedef {import('../Base/index.js').default} Base
- */
-/**
- * Import a component on an interaction.
- *
- * @template {BaseConstructor} T
- * @param {() => Promise<T|{default:T}>} fn
- *   The import function.
- * @param {string|HTMLElement|HTMLElement[]} nameOrSelectorOrElement
- *   The name or selector for the component.
- * @param {string|string[]} events
- *   The events to listen to to trigger the import.
- * @param {Base} [parent]
- *   The parent component.
- * @returns {Promise<T>}
- */
-export default function importOnInteraction<T extends typeof import("../Base/index.js").default>(fn: () => Promise<T | {
-    default: T;
-}>, nameOrSelectorOrElement: string | HTMLElement | HTMLElement[], events: string | string[], parent?: Base): Promise<T>;
-export type BaseConstructor = import('../Base/index.js').BaseConstructor;
-export type Base = import('../Base/index.js').default;

package/helpers/importWhenIdle.d.ts

@@ -1,21 +0,0 @@
-/**
- * @typedef {import('../Base/index.js').BaseConstructor} BaseConstructor
- * @typedef {{ timeout?: number }} ImportWhenIdleOptions
- */
-/**
- * Import a component when user is idle.
- *
- * @template {BaseConstructor} T
- * @param {() => Promise<T|{default:T}>} fn
- *   The import function.
- * @param {ImportWhenIdleOptions} [options]
- *   The time to wait before triggering the callback if never idle.
- * @returns {Promise<T>}
- */
-export default function importWhenIdle<T extends typeof import("../Base/index.js").default>(fn: () => Promise<T | {
-    default: T;
-}>, options?: ImportWhenIdleOptions): Promise<T>;
-export type BaseConstructor = import('../Base/index.js').BaseConstructor;
-export type ImportWhenIdleOptions = {
-    timeout?: number;
-};

package/helpers/importWhenVisible.d.ts

@@ -1,23 +0,0 @@
-/**
- * @typedef {import('../Base/index.js').default} Base
- * @typedef {import('../Base/index.js').BaseConstructor} BaseConstructor
- */
-/**
- * Import a component when it is visible.
- *
- * @template {BaseConstructor} T
- * @param {() => Promise<T|{default:T}>} fn
- *   The import function.
- * @param {string|HTMLElement|HTMLElement[]} nameOrSelectorOrElement
- *   The name or selector for the component.
- * @param {Base} [parent]
- *   The parent component.
- * @param {IntersectionObserverInit} [observerOptions]
- *   Options for the `IntersectionObserver` instance.
- * @returns {Promise<T>}
- */
-export default function importWhenVisible<T extends typeof import("../Base/index.js").default>(fn: () => Promise<T | {
-    default: T;
-}>, nameOrSelectorOrElement: string | HTMLElement | HTMLElement[], parent?: Base, observerOptions?: IntersectionObserverInit): Promise<T>;
-export type Base = import('../Base/index.js').default;
-export type BaseConstructor = import('../Base/index.js').BaseConstructor;

package/helpers/index.d.ts

@@ -1,6 +0,0 @@
-export { default as createApp } from "./createApp.js";
-export * from "./getDirectChildren.js";
-export { default as getInstanceFromElement } from "./getInstanceFromElement.js";
-export { default as importOnInteraction } from "./importOnInteraction.js";
-export { default as importWhenIdle } from "./importWhenIdle.js";
-export { default as importWhenVisible } from "./importWhenVisible.js";

package/helpers/utils.d.ts

@@ -1,10 +0,0 @@
-/**
- * Get the target elements for the lazy import helper functions.
- *
- * @param {string|HTMLElement|HTMLElement[]} nameOrSelectorOrElement
- *   The original selector or element, or list of elements.
- * @param {HTMLElement} [context]
- *   The optional context to use to query for elements.
- * @returns {HTMLElement[]} A normalized list of elements.
- */
-export function getTargetElements(nameOrSelectorOrElement: string | HTMLElement | HTMLElement[], context?: HTMLElement): HTMLElement[];

package/index.d.ts

@@ -1,4 +0,0 @@
-export { default as Base } from "./Base/index.js";
-export * from "./decorators/index.js";
-export * from "./helpers/index.js";
-export * from "./services/index.js";