@dropins/tools 0.23.0-alpha37 → 0.23.0-alpha38

package/package.json

@@ -1 +1 @@
-{"name": "@dropins/tools", "version": "0.23.0-alpha37"}
+{"name": "@dropins/tools", "version": "0.23.0-alpha38"}

package/types.d.ts

@@ -0,0 +1,242 @@
+declare module '@dropins/tools/initializer.js'{ 
+import { Config } from '.';
+
+type Listener = {
+    off(): void;
+};
+type Listeners<T> = (config?: T) => Array<Listener | undefined>;
+type Init<T> = (config?: T) => Promise<void>;
+type Options<T> = {
+    init: Init<T>;
+    listeners: Listeners<T>;
+};
+/**
+ * `Initializer` is a class that represents an initializer.
+ * An initializer is responsible for setting up event listeners and initializing a module.
+ *
+ * @class
+ *
+ * @property {Function} listeners - A method that accepts a config object and returns an array of listeners.
+ * @property {Function} init - A method that initializes the module. It accepts an options object.
+ * @property {Config} config - A Config object that stores the configuration for the module.
+ *
+ * @method constructor - Constructs a new Initializer. Accepts an options object with `init` and `listeners` properties.
+ */
+export declare class Initializer<T> {
+    private _listeners;
+    listeners: Listeners<T>;
+    init: Init<T>;
+    config: Config<T>;
+    /**
+     * Constructs a new Initializer.
+     *
+     * @param {Object} options - The options for the Initializer.
+     * @param {Function} options.listeners - A function that accepts a config object and returns an array of listeners.
+     * @param {Function} options.init - A function that initializes the module. It accepts an options object.
+     */
+    constructor({ init, listeners }: Options<T>);
+}
+type Initializers = [Initializer<any>, {
+    [key: string]: any;
+} | undefined][];
+/**
+ * Class representing initializerss.
+ *
+ * @class
+ *
+ * @method register - Registers a new initializer. If the initializers have already been mounted, it also immediately binds the event listeners and initializes the API for the new initializer.
+ * @method mount - Mounts all registered initializers. This involves binding the event listeners and initializing the APIs for each initializer, in that order.
+ * @method setImageParamKeys - Sets the image parameter keys. These keys are used when initializing the APIs for the initializers.
+ */
+export declare class initializers {
+    static _initializers: Initializers;
+    static _mounted: boolean;
+    static _imageParamsKeyMap: {
+        [key: string]: string;
+    } | undefined;
+    /**
+     * Registers a new initializer.
+     *
+     * @param {Initializer<any>} initializer - The initializer to register. This should be an object with `listeners` and `init` methods.
+     * @param {Object.<string, any>} [options] - An optional object with additional options. These options are passed to the `listeners` and `init` methods of the initializer.
+     */
+    static register(initializer: Initializer<any>, options?: {
+        [key: string]: any;
+    }): void;
+    /**
+     * Mounts all registered initializers.
+     *
+     * @returns {void}
+     */
+    static mount(): void;
+    /**
+     * Sets the image parameter keys.
+     *
+     * @param {Object.<string, any>} params - An object mapping keys to values.
+     * @returns {void}
+     */
+    static setImageParamKeys(params: {
+        [key: string]: any;
+    }): void;
+}
+export {};
+//# sourceMappingURL=initializer.d.ts.map
+}
+
+declare module '@dropins/tools/event-bus.js'{ 
+import { Events } from './events-catalog';
+
+export * from './events-catalog';
+/**
+ * `events` is a class that provides static methods for event handling.
+ *
+ * @class
+ * @extends {Events}
+ *
+ * @property {Function} on - Subscribes to an event. Accepts an event name, a handler function, and an optional options object.
+ * @property {Function} emit - Emits an event. Accepts an event name and a payload.
+ * @property {Function} enableLogger - Enables or disables logging of events. Accepts a boolean.
+ */
+export declare class events {
+    static _identifier: string;
+    static _logger: BroadcastChannel | null;
+    static _lastEvent: {
+        [key: string]: {
+            payload: any;
+        };
+    };
+    /**
+     * Subscribes to an event.
+     *
+     * @param {string} event - The name of the event to subscribe to.
+     * @param {Function} handler - The function to call when the event is emitted.
+     * @param {Object} [options] - An optional object with additional options.
+     * @param {boolean} [options.eager] - If true, the handler will be called immediately with the last emitted event.
+     */
+    static on<K extends keyof Events>(event: K, handler: (payload: Events[K]) => void, options?: {
+        eager?: boolean;
+    }): {
+        off(): void;
+    } | undefined;
+    /**
+     * Emits an event.
+     *
+     * @param {string} event - The name of the event to emit.
+     * @param {*} payload - The data to send with the event.
+     */
+    static emit<K extends keyof Events>(event: K, payload: Events[K]): void;
+    /**
+     * Enables or disables logging of events.
+     *
+     * @param {boolean} enabled - If true, events will be logged to the console.
+     */
+    static enableLogger(enabled: boolean): void;
+}
+//# sourceMappingURL=index.d.ts.map
+}
+
+declare module '@dropins/tools/fetch-graphql.js'{ 
+/**
+ * @typedef {Object} Header
+ * @property {string|null} key - The header name and value.
+ */
+export type Header = {
+    [key: string]: string | null;
+};
+/**
+ * Type representing options for a fetch request.
+ * @typedef {Object} FetchOptions
+ * @property {'GET'|'POST'} [method] - The HTTP method to use for the request.
+ * @property {Object} [variables] - Variables to include in the request.
+ * @property {AbortSignal} [signal] - An AbortSignal to cancel the request.
+ * @property {'default'|'no-store'|'reload'|'no-cache'|'force-cache'|'only-if-cached'} [cache] - The cache mode to use for the request.
+ */
+export type FetchOptions = {
+    method?: 'GET' | 'POST';
+    variables?: {
+        [key: string]: any;
+    };
+    signal?: AbortSignal;
+    cache?: 'default' | 'no-store' | 'reload' | 'no-cache' | 'force-cache' | 'only-if-cached';
+};
+/**
+ * Represents an array of error objects that might be returned from a fetch query.
+ * Each error object contains a message and extensions with a category.
+ *
+ * @typedef {Object} FetchQueryError
+ * @property {string} message - The error message.
+ * @property {Object} extensions - Additional error information.
+ * @property {string} extensions.category - The category of the error.
+ */
+export type FetchQueryError = Array<{
+    message: string;
+    extensions: {
+        category: string;
+    };
+}>;
+declare class FetchGraphQLMesh {
+    _endpoint?: string;
+    get endpoint(): string | undefined;
+    get fetchGraphQlHeaders(): Header | undefined;
+    _fetchGraphQlHeaders: Header | undefined;
+    setEndpoint(endpoint: string): void;
+    setFetchGraphQlHeader(key: string, value: string | null): void;
+    removeFetchGraphQlHeader(key: string): void;
+    setFetchGraphQlHeaders(header: Header): void;
+    fetchGraphQl<T = any>(query: string, options?: FetchOptions): Promise<{
+        errors?: FetchQueryError;
+        data: T;
+    }>;
+    getConfig(): {
+        endpoint: string | undefined;
+        fetchGraphQlHeaders: Header | undefined;
+    };
+    getMethods(): {
+        setEndpoint: (endpoint: string) => void;
+        setFetchGraphQlHeader: (key: string, value: string | null) => void;
+        removeFetchGraphQlHeader: (key: string) => void;
+        setFetchGraphQlHeaders: (header: Header) => void;
+        fetchGraphQl: <T = any>(query: string, options?: FetchOptions | undefined) => Promise<{
+            errors?: FetchQueryError | undefined;
+            data: T;
+        }>;
+        getConfig: () => {
+            endpoint: string | undefined;
+            fetchGraphQlHeaders: Header | undefined;
+        };
+    };
+}
+/**
+ * `FetchGraphQL` is a class that extends `FetchGraphQLMesh`. It provides methods to get the GraphQL endpoint and headers.
+ *
+ * @property {string} endpoint - Gets the GraphQL endpoint. If `_endpoint` is not defined, it will return the `mesh.endpoint`.
+ * @property {Object} fetchGraphQlHeaders - Gets the GraphQL headers. If `_endpoint` is defined, it will return `_fetchGraphQlHeaders`.
+ * Otherwise, it will return a combination of `_fetchGraphQlHeaders` and `mesh.fetchGraphQlHeaders`.
+ * If neither is defined, it will return an empty object.
+ *
+ * @extends FetchGraphQLMesh
+ */
+export declare class FetchGraphQL extends FetchGraphQLMesh {
+    get endpoint(): string | undefined;
+    get fetchGraphQlHeaders(): Header;
+}
+/**
+ * Exports several methods from the `mesh` object.
+ *
+ * @property {Function} setEndpoint - Sets the GraphQL endpoint. Accepts a string as parameter.
+ * @property {Function} setFetchGraphQlHeaders - Sets the GraphQL headers. Accepts an object of headers as parameter.
+ * @property {Function} setFetchGraphQlHeader - Sets a specific GraphQL header. Accepts a key-value pair as parameters.
+ * @property {Function} removeFetchGraphQlHeader - Removes a specific GraphQL header. Accepts the key of the header as parameter.
+ * @property {Function} fetchGraphQl - Fetches GraphQL data. Accepts a query string and an optional options object as parameters. Returns a promise that resolves with the fetched data.
+ * @property {Function} getConfig - Gets the configuration. Returns an object with the endpoint and GraphQL headers.
+ */
+export declare const setEndpoint: (endpoint: string) => void, setFetchGraphQlHeaders: (header: Header) => void, setFetchGraphQlHeader: (key: string, value: string | null) => void, removeFetchGraphQlHeader: (key: string) => void, fetchGraphQl: <T = any>(query: string, options?: FetchOptions) => Promise<{
+    errors?: FetchQueryError | undefined;
+    data: T;
+}>, getConfig: () => {
+    endpoint: string | undefined;
+    fetchGraphQlHeaders: Header | undefined;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map
+}