@kuindji/reactive 1.0.0

package/dist/action.d.ts

@@ -0,0 +1,49 @@
+import type { ApiType, BaseHandler, ErrorListenerSignature, ErrorResponse } from "./lib/types";
+export type ActionResponse<Response extends any = any, Args extends any[] = any[]> = {
+    response: Response;
+    error: null;
+    args: Args;
+} | {
+    response: null;
+    error: string;
+    args: Args;
+};
+export type ListenerSignature<ActionSignature extends BaseHandler> = (arg: ActionResponse<Awaited<ReturnType<ActionSignature>>, Parameters<ActionSignature>>) => void;
+export type ActionDefinitionHelper<A extends BaseHandler> = {
+    actionSignature: A;
+    actionArguments: Parameters<A>;
+    actionReturnType: Awaited<ReturnType<A>>;
+    responseType: ActionResponse<Awaited<ReturnType<A>>, Parameters<A>>;
+    errorResponseType: ErrorResponse<Parameters<A>>;
+    listenerArgument: ActionResponse<Awaited<ReturnType<A>>, Parameters<A>>;
+    listenerSignature: ListenerSignature<A>;
+    errorListenerArgument: ErrorResponse<Parameters<A>>;
+    errorListenerSignature: ErrorListenerSignature<Parameters<A>>;
+};
+export declare function createAction<A extends BaseHandler>(action: A): ApiType<ActionDefinitionHelper<A>, {
+    readonly invoke: (...args: Parameters<A>) => Promise<ActionResponse<Awaited<ReturnType<A>>, Parameters<A>>>;
+    readonly addListener: (handler: ListenerSignature<A>, listenerOptions?: import("./event").ListenerOptions) => void;
+    /** @alias addListener */
+    readonly on: (handler: ListenerSignature<A>, listenerOptions?: import("./event").ListenerOptions) => void;
+    /** @alias addListener */
+    readonly subscribe: (handler: ListenerSignature<A>, listenerOptions?: import("./event").ListenerOptions) => void;
+    /** @alias addListener */
+    readonly listen: (handler: ListenerSignature<A>, listenerOptions?: import("./event").ListenerOptions) => void;
+    readonly removeAllListeners: (tag?: string) => void;
+    readonly removeListener: (handler: ListenerSignature<A>, context?: object | null, tag?: string | null) => boolean;
+    /** @alias removeListener */
+    readonly un: (handler: ListenerSignature<A>, context?: object | null, tag?: string | null) => boolean;
+    /** @alias removeListener */
+    readonly off: (handler: ListenerSignature<A>, context?: object | null, tag?: string | null) => boolean;
+    /** @alias removeListener */
+    readonly remove: (handler: ListenerSignature<A>, context?: object | null, tag?: string | null) => boolean;
+    /** @alias removeListener */
+    readonly unsubscribe: (handler: ListenerSignature<A>, context?: object | null, tag?: string | null) => boolean;
+    readonly promise: (options?: import("./event").ListenerOptions) => Promise<[arg: ActionResponse<Awaited<ReturnType<A>>, Parameters<A>>]>;
+    readonly addErrorListener: (handler: ErrorListenerSignature<Parameters<A>>, listenerOptions?: import("./event").ListenerOptions) => void;
+    readonly removeAllErrorListeners: (tag?: string) => void;
+    readonly removeErrorListener: (handler: ErrorListenerSignature<Parameters<A>>, context?: object | null, tag?: string | null) => boolean;
+    readonly errorPromise: (options?: import("./event").ListenerOptions) => Promise<[errorResponse: ErrorResponse<Parameters<A>>]>;
+}>;
+export type BaseActionDefinition = ActionDefinitionHelper<(...args: [any]) => any>;
+export type BaseAction = ReturnType<typeof createAction<(...args: [any]) => any>>;

package/dist/action.js

@@ -0,0 +1,77 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAction = createAction;
+const event_1 = require("./event");
+function createAction(action) {
+    const { trigger, addListener, removeAllListeners, removeListener, promise, } = (0, event_1.createEvent)();
+    const { trigger: triggerError, addListener: addErrorListener, removeAllListeners: removeAllErrorListeners, removeListener: removeErrorListener, promise: errorPromise, hasListener: hasErrorListeners, } = (0, event_1.createEvent)();
+    const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            let result = action(...args);
+            if (result instanceof Promise) {
+                result = yield result;
+            }
+            const response = {
+                response: result,
+                error: null,
+                args: args,
+            };
+            trigger(response);
+            return response;
+        }
+        catch (error) {
+            if (!hasErrorListeners()) {
+                throw error;
+            }
+            const response = {
+                response: null,
+                error: error instanceof Error ? error.message : error,
+                args: args,
+            };
+            trigger(response);
+            triggerError({
+                error: error instanceof Error
+                    ? error
+                    : new Error(error),
+                args: args,
+                type: "action",
+            });
+            return response;
+        }
+    });
+    const api = {
+        invoke,
+        addListener,
+        /** @alias addListener */
+        on: addListener,
+        /** @alias addListener */
+        subscribe: addListener,
+        /** @alias addListener */
+        listen: addListener,
+        removeAllListeners,
+        removeListener,
+        /** @alias removeListener */
+        un: removeListener,
+        /** @alias removeListener */
+        off: removeListener,
+        /** @alias removeListener */
+        remove: removeListener,
+        /** @alias removeListener */
+        unsubscribe: removeListener,
+        promise,
+        addErrorListener,
+        removeAllErrorListeners,
+        removeErrorListener,
+        errorPromise,
+    };
+    return api;
+}

package/dist/actionBus.d.ts

@@ -0,0 +1,43 @@
+import { ActionDefinitionHelper, createAction } from "./action";
+import { ListenerOptions } from "./event";
+import type { ApiType, BaseHandler, ErrorListenerSignature, KeyOf, MapKey } from "./lib/types";
+export interface BaseActionsMap {
+    [key: MapKey]: BaseHandler;
+}
+type GetActionTypesMap<ActionsMap extends BaseActionsMap> = {
+    [key in KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : ReturnType<typeof createAction<ActionsMap[key]>>;
+};
+type GetActionDefinitionsMap<ActionsMap extends BaseActionsMap> = {
+    [key in KeyOf<ActionsMap>]: [ActionsMap[key]] extends [never] ? never : ActionDefinitionHelper<ActionsMap[key]>;
+};
+export type ActionBusDefinitionHelper<ActionsMap extends BaseActionsMap> = {
+    actions: GetActionDefinitionsMap<ActionsMap>;
+    actionTypes: GetActionTypesMap<ActionsMap>;
+};
+export declare function createActionBus<ActionsMap extends BaseActionsMap>(initialActions?: ActionsMap, errorListener?: ErrorListenerSignature<any[]>): ApiType<ActionBusDefinitionHelper<ActionsMap>, {
+    readonly add: (name: MapKey, action: BaseHandler) => void;
+    readonly get: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K) => GetActionTypesMap<ActionsMap>[K];
+    readonly invoke: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K, ...args: GetActionDefinitionsMap<ActionsMap>[K]["actionArguments"]) => Promise<import("./action").ActionResponse<Awaited<ReturnType<ActionsMap[K]>>, Parameters<ActionsMap[K]>>>;
+    readonly addListener: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K, handler: GetActionDefinitionsMap<ActionsMap>[K]["listenerSignature"], options?: ListenerOptions) => void;
+    /** @alias addListener */
+    readonly on: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K, handler: GetActionDefinitionsMap<ActionsMap>[K]["listenerSignature"], options?: ListenerOptions) => void;
+    /** @alias addListener */
+    readonly subscribe: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K, handler: GetActionDefinitionsMap<ActionsMap>[K]["listenerSignature"], options?: ListenerOptions) => void;
+    /** @alias addListener */
+    readonly listen: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K, handler: GetActionDefinitionsMap<ActionsMap>[K]["listenerSignature"], options?: ListenerOptions) => void;
+    readonly once: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K, handler: GetActionDefinitionsMap<ActionsMap>[K]["listenerSignature"], options?: ListenerOptions) => void;
+    readonly removeListener: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K, handler: GetActionDefinitionsMap<ActionsMap>[K]["listenerSignature"], context?: object | null, tag?: string | null) => boolean;
+    /** @alias removeListener */
+    readonly off: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K, handler: GetActionDefinitionsMap<ActionsMap>[K]["listenerSignature"], context?: object | null, tag?: string | null) => boolean;
+    /** @alias removeListener */
+    readonly remove: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K, handler: GetActionDefinitionsMap<ActionsMap>[K]["listenerSignature"], context?: object | null, tag?: string | null) => boolean;
+    /** @alias removeListener */
+    readonly un: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K, handler: GetActionDefinitionsMap<ActionsMap>[K]["listenerSignature"], context?: object | null, tag?: string | null) => boolean;
+    /** @alias removeListener */
+    readonly unsubscribe: <K extends KeyOf<GetActionDefinitionsMap<ActionsMap>>>(name: K, handler: GetActionDefinitionsMap<ActionsMap>[K]["listenerSignature"], context?: object | null, tag?: string | null) => boolean;
+    readonly addErrorListener: (handler: ErrorListenerSignature<any[]>, listenerOptions?: ListenerOptions) => void;
+    readonly removeErrorListener: (handler: ErrorListenerSignature<any[]>, context?: object | null, tag?: string | null) => boolean;
+}>;
+export type BaseActionBusDefinition = ActionBusDefinitionHelper<BaseActionsMap>;
+export type BaseActionBus = ReturnType<typeof createActionBus<BaseActionsMap>>;
+export {};

package/dist/actionBus.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createActionBus = createActionBus;
+const action_1 = require("./action");
+const event_1 = require("./event");
+function createActionBus(initialActions = {}, errorListener) {
+    const actions = new Map();
+    const errorEvent = (0, event_1.createEvent)();
+    if (errorListener) {
+        errorEvent.addListener(({ error, args }) => {
+            errorEvent.emit({ error, args, type: "action" });
+        });
+    }
+    const add = (name, action) => {
+        if (!actions.has(name)) {
+            const a = (0, action_1.createAction)(action);
+            a.addErrorListener(({ error, args }) => {
+                errorEvent.emit({ name, error, args, type: "action" });
+            });
+            actions.set(name, a);
+        }
+    };
+    Object.entries(initialActions).forEach(([name, action]) => {
+        add(name, action);
+    });
+    const get = (name) => {
+        return actions.get(name);
+    };
+    const invoke = (name, ...args) => {
+        const action = get(name);
+        return action.invoke(...args);
+    };
+    const on = (name, handler, options) => {
+        const action = get(name);
+        if (!action) {
+            throw new Error(`Action ${name} not found`);
+        }
+        return action.addListener(handler, options);
+    };
+    const once = (name, handler, options) => {
+        options = options || {};
+        options.limit = 1;
+        const action = get(name);
+        if (!action) {
+            throw new Error(`Action ${name} not found`);
+        }
+        return action.addListener(handler, options);
+    };
+    const un = (name, handler, context, tag) => {
+        const action = get(name);
+        if (!action) {
+            throw new Error(`Action ${name} not found`);
+        }
+        return action.removeListener(handler, context, tag);
+    };
+    const api = {
+        add,
+        get,
+        invoke,
+        addListener: on,
+        /** @alias addListener */
+        on,
+        /** @alias addListener */
+        subscribe: on,
+        /** @alias addListener */
+        listen: on,
+        once,
+        removeListener: un,
+        /** @alias removeListener */
+        off: un,
+        /** @alias removeListener */
+        remove: un,
+        /** @alias removeListener */
+        un: un,
+        /** @alias removeListener */
+        unsubscribe: un,
+        addErrorListener: errorEvent.addListener,
+        removeErrorListener: errorEvent.removeListener,
+    };
+    return api;
+}

package/dist/actionMap.d.ts

@@ -0,0 +1,23 @@
+import type { ActionResponse } from "./action";
+import type { BaseActionsMap } from "./actionBus";
+import type { ErrorListenerSignature, ErrorResponse, KeyOf } from "./lib/types";
+export type { ActionResponse, BaseActionsMap, ErrorListenerSignature, ErrorResponse, };
+export declare function createActionMap<M extends BaseActionsMap>(actions: M, onAnyError?: ErrorListenerSignature<any[]> | ErrorListenerSignature<any[]>[]): { [key in KeyOf<M>]: {
+    readonly invoke: (...args: Parameters<M[key]>) => Promise<ActionResponse<Awaited<ReturnType<M[key]>>, Parameters<M[key]>>>;
+    readonly addListener: (handler: import("./action").ListenerSignature<M[key]>, listenerOptions?: import("./event").ListenerOptions) => void;
+    readonly on: (handler: import("./action").ListenerSignature<M[key]>, listenerOptions?: import("./event").ListenerOptions) => void;
+    readonly subscribe: (handler: import("./action").ListenerSignature<M[key]>, listenerOptions?: import("./event").ListenerOptions) => void;
+    readonly listen: (handler: import("./action").ListenerSignature<M[key]>, listenerOptions?: import("./event").ListenerOptions) => void;
+    readonly removeAllListeners: (tag?: string) => void;
+    readonly removeListener: (handler: import("./action").ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
+    readonly un: (handler: import("./action").ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
+    readonly off: (handler: import("./action").ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
+    readonly remove: (handler: import("./action").ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
+    readonly unsubscribe: (handler: import("./action").ListenerSignature<M[key]>, context?: object | null, tag?: string | null) => boolean;
+    readonly promise: (options?: import("./event").ListenerOptions) => Promise<[arg: ActionResponse<Awaited<ReturnType<M[key]>>, Parameters<M[key]>>]>;
+    readonly addErrorListener: (handler: ErrorListenerSignature<Parameters<M[key]>>, listenerOptions?: import("./event").ListenerOptions) => void;
+    readonly removeAllErrorListeners: (tag?: string) => void;
+    readonly removeErrorListener: (handler: ErrorListenerSignature<Parameters<M[key]>>, context?: object | null, tag?: string | null) => boolean;
+    readonly errorPromise: (options?: import("./event").ListenerOptions) => Promise<[errorResponse: ErrorResponse<Parameters<M[key]>>]>;
+    __type: import("./action").ActionDefinitionHelper<M[key]>;
+}; };

package/dist/actionMap.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createActionMap = createActionMap;
+const action_1 = require("./action");
+function createActionMap(actions, onAnyError) {
+    const errorListenersMap = {};
+    for (const key in actions) {
+        errorListenersMap[key] = (errorResponse) => {
+            if (Array.isArray(onAnyError)) {
+                for (const listener of onAnyError) {
+                    listener === null || listener === void 0 ? void 0 : listener(Object.assign({ name: key }, errorResponse));
+                }
+            }
+            else {
+                onAnyError === null || onAnyError === void 0 ? void 0 : onAnyError(Object.assign({ name: key }, errorResponse));
+            }
+        };
+    }
+    const map = {};
+    for (const key in actions) {
+        const action = (0, action_1.createAction)(actions[key]);
+        action.addErrorListener(errorListenersMap[key]);
+        map[key] = action;
+    }
+    return map;
+}

package/dist/event.d.ts

@@ -0,0 +1,143 @@
+import type { ApiType, BaseHandler, ErrorListenerSignature } from "./lib/types";
+type Unarray<T> = T extends (infer U)[] ? U : T;
+interface BaseOptions {
+    /**
+     * Call this listener asynchronously.
+     */
+    async?: boolean | number | null;
+}
+export interface ListenerOptions extends BaseOptions {
+    /**
+     * Call handler this number of times; 0 for unlimited
+     * @default 0
+     */
+    limit?: number;
+    /**
+     * True to prepend to the list of listeners
+     * @default false
+     */
+    first?: boolean;
+    /**
+     * True to always run this listener before others
+     * @default false
+     */
+    alwaysFirst?: boolean;
+    /**
+     * True to always run this listener after others
+     * @default false
+     */
+    alwaysLast?: boolean;
+    /**
+     * Start calling listener after this number of calls. Starts from 1
+     * @default 1
+     */
+    start?: number;
+    /**
+     * Listener's context (this) object
+     */
+    context?: object | null;
+    /**
+     * Listener tags
+     */
+    tags?: string[];
+    /**
+     * You can pass any additional fields here. They will be passed back to TriggerFilter
+     */
+    extraData?: any;
+}
+interface ListenerPrototype<Handler extends BaseHandler> extends Required<ListenerOptions> {
+    handler: Handler;
+    called: number;
+    count: number;
+    index: number;
+    start: number;
+}
+export interface EventOptions<ListenerSignature extends BaseHandler> extends BaseOptions {
+    /**
+     * Call this event this number of times; 0 for unlimited
+     * @default 0
+     */
+    limit?: number | null;
+    /**
+     * Trigger newly added listeners automatically this last trigger arguments
+     * @default false
+     */
+    autoTrigger?: boolean | null;
+    /**
+     * A function that decides whether event should trigger a listener this time
+     */
+    filter?: ((args: any[], listener: ListenerPrototype<ListenerSignature>) => boolean) | null;
+    /**
+     * TriggerFilter's this object, if needed
+     */
+    filterContext?: object | null;
+    /**
+     * Maximum number of listeners to add
+     * @default 1000
+     */
+    maxListeners?: number;
+}
+export type EventDefinitionHelper<ListenerSignature extends BaseHandler = BaseHandler> = {
+    signature: ListenerSignature;
+    arguments: Parameters<ListenerSignature>;
+    returnType: ReturnType<ListenerSignature>;
+    options: EventOptions<ListenerSignature>;
+    errorListenerSignature: ErrorListenerSignature<Parameters<ListenerSignature>>;
+};
+export declare function createEvent<ListenerSignature extends BaseHandler>(eventOptions?: EventOptions<ListenerSignature>): ApiType<EventDefinitionHelper<ListenerSignature>, {
+    readonly addListener: (handler: ListenerSignature, listenerOptions?: ListenerOptions) => void;
+    /** @alias addListener */
+    readonly on: (handler: ListenerSignature, listenerOptions?: ListenerOptions) => void;
+    /** @alias addListener */
+    readonly listen: (handler: ListenerSignature, listenerOptions?: ListenerOptions) => void;
+    /** @alias addListener */
+    readonly subscribe: (handler: ListenerSignature, listenerOptions?: ListenerOptions) => void;
+    readonly removeListener: (handler: ListenerSignature, context?: object | null, tag?: string | null) => boolean;
+    /** @alias removeListener */
+    readonly un: (handler: ListenerSignature, context?: object | null, tag?: string | null) => boolean;
+    /** @alias removeListener */
+    readonly off: (handler: ListenerSignature, context?: object | null, tag?: string | null) => boolean;
+    /** @alias removeListener */
+    readonly remove: (handler: ListenerSignature, context?: object | null, tag?: string | null) => boolean;
+    /** @alias removeListener */
+    readonly unsubscribe: (handler: ListenerSignature, context?: object | null, tag?: string | null) => boolean;
+    readonly trigger: (...args: Parameters<ListenerSignature>) => void;
+    /** @alias trigger */
+    readonly emit: (...args: Parameters<ListenerSignature>) => void;
+    /** @alias trigger */
+    readonly dispatch: (...args: Parameters<ListenerSignature>) => void;
+    readonly hasListener: (handler?: ListenerSignature | null, context?: object | null, tag?: string | null) => boolean;
+    /** @alias hasListener */
+    readonly has: (handler?: ListenerSignature | null, context?: object | null, tag?: string | null) => boolean;
+    readonly removeAllListeners: (tag?: string) => void;
+    readonly addErrorListener: (handler: ErrorListenerSignature<Parameters<ListenerSignature>>, context?: object | null) => void;
+    readonly removeErrorListener: (handler: ErrorListenerSignature<Parameters<ListenerSignature>>, context?: object | null) => boolean;
+    readonly suspend: (withQueue?: boolean) => void;
+    readonly resume: () => void;
+    readonly setOptions: (eventOptions: Pick<EventOptions<ListenerSignature>, "async" | "limit" | "autoTrigger">) => void;
+    readonly reset: () => void;
+    readonly isSuspended: () => boolean;
+    readonly isQueued: () => boolean;
+    readonly withTags: <T extends (...args: any[]) => any>(tags: string[], callback: T) => ReturnType<T>;
+    readonly promise: (options?: ListenerOptions) => Promise<Parameters<ListenerSignature>>;
+    readonly first: (...args: Parameters<ListenerSignature>) => ReturnType<ListenerSignature> | undefined;
+    readonly resolveFirst: (...args: Parameters<ListenerSignature>) => Promise<Awaited<ReturnType<ListenerSignature>> | undefined>;
+    readonly all: (...args: Parameters<ListenerSignature>) => ReturnType<ListenerSignature>[];
+    readonly resolveAll: (...args: Parameters<ListenerSignature>) => Promise<Awaited<ReturnType<ListenerSignature>>[]>;
+    readonly last: (...args: Parameters<ListenerSignature>) => ReturnType<ListenerSignature> | undefined;
+    readonly resolveLast: (...args: Parameters<ListenerSignature>) => Promise<Awaited<ReturnType<ListenerSignature>> | undefined>;
+    readonly merge: (...args: Parameters<ListenerSignature>) => ReturnType<ListenerSignature> | undefined;
+    readonly resolveMerge: (...args: Parameters<ListenerSignature>) => Promise<Awaited<ReturnType<ListenerSignature>> | undefined>;
+    readonly concat: (...args: Parameters<ListenerSignature>) => Unarray<ReturnType<ListenerSignature>>[];
+    readonly resolveConcat: (...args: Parameters<ListenerSignature>) => Promise<Unarray<Awaited<ReturnType<ListenerSignature>>>[]>;
+    readonly firstNonEmpty: (...args: Parameters<ListenerSignature>) => ReturnType<ListenerSignature> | undefined;
+    readonly resolveFirstNonEmpty: (...args: Parameters<ListenerSignature>) => Promise<Awaited<ReturnType<ListenerSignature>> | undefined>;
+    readonly untilTrue: (...args: Parameters<ListenerSignature>) => void;
+    readonly untilFalse: (...args: Parameters<ListenerSignature>) => void;
+    readonly pipe: (...args: Parameters<ListenerSignature>) => ReturnType<ListenerSignature> | undefined;
+    readonly resolvePipe: (...args: Parameters<ListenerSignature>) => Promise<Awaited<ReturnType<ListenerSignature>> | undefined>;
+    readonly raw: (...args: Parameters<ListenerSignature>) => Unarray<ReturnType<ListenerSignature>>[];
+}>;
+export type BaseEventDefinition = EventDefinitionHelper<BaseHandler>;
+export type BaseEvent = ReturnType<typeof createEvent<BaseHandler>>;
+export {};