@nlabs/gothamui 1.8.0

package/lib/utils/imageUtils.js

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ export const convertFileToBase64 = (file, maxSize)=>new Promise((resolve, reject)=>{
+        const reader = new FileReader();
+        reader.onload = ()=>{
+            const image = new Image();
+            image.onload = ()=>{
+                // Resize the image
+                const canvas = document.createElement('canvas');
+                const { height, width } = image;
+                let updatedHeight = height;
+                let updatedWidth = width;
+                if (width > height) {
+                    if (width > maxSize) {
+                        updatedHeight *= maxSize / width;
+                        updatedWidth = maxSize;
+                    }
+                } else if (height > maxSize) {
+                    updatedWidth *= maxSize / height;
+                    updatedHeight = maxSize;
+                }
+                canvas.width = updatedWidth;
+                canvas.height = updatedHeight;
+                canvas.getContext('2d')?.drawImage(image, 0, 0, updatedWidth, updatedHeight);
+                const dataUrl = canvas.toDataURL('image/jpeg');
+                // const resizedImage = dataURLToBlob(dataUrl);
+                resolve(dataUrl);
+            // $.event.trigger({
+            //   type: 'imageResized',
+            //   blob: resizedImage,
+            //   url: dataUrl
+            // });
+            };
+            const originalBase64 = reader.result;
+            image.src = originalBase64;
+        };
+        // reader.onloadend = () => {
+        //   const base64: string = reader.result as string;
+        //   resolve(base64);
+        // };
+        reader.onerror = (event)=>{
+            reject(event);
+        };
+        reader.readAsDataURL(file);
+    });
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/interactionAnalytics.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) 2026-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+import type { AwsRum } from './awsRum.js';
+/**
+ * Tracks semantic interactions with one delegated listener per event type.
+ * Values, visible text, URLs, and query strings are deliberately excluded.
+ */
+export declare const registerInteractionAnalytics: (awsRum: AwsRum, ownerDocument?: Document | undefined) => (() => void);

package/lib/utils/interactionAnalytics.js

@@ -0,0 +1,142 @@
+/**
+ * Copyright (c) 2026-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ const ACTIVATION_SELECTOR = [
+    'a[href]',
+    'area[href]',
+    'button',
+    'input[type="button"]',
+    'input[type="image"]',
+    'input[type="reset"]',
+    'input[type="submit"]',
+    'summary',
+    '[role="button"]',
+    '[role="checkbox"]',
+    '[role="link"]',
+    '[role="menuitem"]',
+    '[role="menuitemcheckbox"]',
+    '[role="menuitemradio"]',
+    '[role="option"]',
+    '[role="radio"]',
+    '[role="slider"]',
+    '[role="switch"]',
+    '[role="tab"]',
+    '[role="treeitem"]',
+    '[data-analytics-interaction="click"]'
+].join(',');
+const EDITABLE_SELECTOR = '[contenteditable=""], [contenteditable="true"]';
+const KEYBOARD_VALUE_SELECTOR = '[role="slider"], [role="spinbutton"]';
+const VALUE_KEYS = new Set([
+    'ArrowDown',
+    'ArrowLeft',
+    'ArrowRight',
+    'ArrowUp',
+    'End',
+    'Home',
+    'PageDown',
+    'PageUp'
+]);
+const NATIVE_VALUE_SELECTOR = [
+    'input:not([type="button"]):not([type="hidden"]):not([type="image"]):not([type="reset"]):not([type="submit"])',
+    'select',
+    'textarea'
+].join(',');
+const VALUE_SELECTOR = [
+    NATIVE_VALUE_SELECTOR,
+    '[role="checkbox"]',
+    '[role="combobox"]',
+    '[role="listbox"]',
+    '[role="radio"]',
+    '[role="slider"]',
+    '[role="spinbutton"]',
+    '[role="switch"]',
+    '[data-analytics-interaction="change"]'
+].join(',');
+const findTarget = (event, selector)=>{
+    const path = typeof event.composedPath === 'function' ? event.composedPath() : [
+        event.target
+    ];
+    return path.find((item)=>item instanceof Element && item.matches(selector));
+};
+const getControl = (element)=>{
+    const role = element.getAttribute('role');
+    if (role) {
+        return role;
+    }
+    if (element instanceof HTMLInputElement) {
+        return `input.${element.type || 'text'}`;
+    }
+    return element.tagName.toLowerCase();
+};
+const isTrackable = (element)=>{
+    const disabled = element.getAttribute('aria-disabled') === 'true' || element instanceof HTMLButtonElement && element.disabled || element instanceof HTMLInputElement && element.disabled || element instanceof HTMLSelectElement && element.disabled || element instanceof HTMLTextAreaElement && element.disabled;
+    return !disabled && !element.closest('[data-analytics-track="false"]');
+};
+const trackInteraction = (awsRum, element, interaction)=>{
+    if (!isTrackable(element)) {
+        return;
+    }
+    const analyticsName = element.getAttribute('data-analytics-name')?.trim();
+    awsRum.track({
+        name: analyticsName || 'interaction',
+        path: globalThis.location?.pathname,
+        properties: {
+            control: getControl(element),
+            interaction
+        },
+        type: interaction === 'activate' ? 'click' : interaction
+    });
+};
+/**
+ * Tracks semantic interactions with one delegated listener per event type.
+ * Values, visible text, URLs, and query strings are deliberately excluded.
+ */ export const registerInteractionAnalytics = (awsRum, ownerDocument = globalThis.document)=>{
+    if (!ownerDocument) {
+        return ()=>{};
+    }
+    const handleBlur = (event)=>{
+        const target = findTarget(event, EDITABLE_SELECTOR);
+        if (target) {
+            trackInteraction(awsRum, target, 'edit');
+        }
+    };
+    const handleChange = (event)=>{
+        const target = findTarget(event, VALUE_SELECTOR);
+        if (target) {
+            trackInteraction(awsRum, target, 'change');
+        }
+    };
+    const handleClick = (event)=>{
+        const target = findTarget(event, ACTIVATION_SELECTOR);
+        if (target && !target.matches(NATIVE_VALUE_SELECTOR)) {
+            trackInteraction(awsRum, target, 'activate');
+        }
+    };
+    const handleSubmit = (event)=>{
+        const submitEvent = event;
+        if (!submitEvent.submitter && event.target instanceof HTMLFormElement) {
+            trackInteraction(awsRum, event.target, 'submit');
+        }
+    };
+    const handleValueKey = (event)=>{
+        const keyboardEvent = event;
+        const target = findTarget(event, KEYBOARD_VALUE_SELECTOR);
+        if (target && VALUE_KEYS.has(keyboardEvent.key)) {
+            trackInteraction(awsRum, target, 'change');
+        }
+    };
+    ownerDocument.addEventListener('blur', handleBlur, true);
+    ownerDocument.addEventListener('change', handleChange, true);
+    ownerDocument.addEventListener('click', handleClick, true);
+    ownerDocument.addEventListener('keyup', handleValueKey, true);
+    ownerDocument.addEventListener('submit', handleSubmit, true);
+    return ()=>{
+        ownerDocument.removeEventListener('blur', handleBlur, true);
+        ownerDocument.removeEventListener('change', handleChange, true);
+        ownerDocument.removeEventListener('click', handleClick, true);
+        ownerDocument.removeEventListener('keyup', handleValueKey, true);
+        ownerDocument.removeEventListener('submit', handleSubmit, true);
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/gothamjs/src/utils/interactionAnalytics.ts"],"sourcesContent":["/**\n * Copyright (c) 2026-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport type {AwsRum} from './awsRum.js';\n\ntype InteractionKind = 'activate' | 'change' | 'edit' | 'submit';\n\nconst ACTIVATION_SELECTOR = [\n  'a[href]',\n  'area[href]',\n  'button',\n  'input[type=\"button\"]',\n  'input[type=\"image\"]',\n  'input[type=\"reset\"]',\n  'input[type=\"submit\"]',\n  'summary',\n  '[role=\"button\"]',\n  '[role=\"checkbox\"]',\n  '[role=\"link\"]',\n  '[role=\"menuitem\"]',\n  '[role=\"menuitemcheckbox\"]',\n  '[role=\"menuitemradio\"]',\n  '[role=\"option\"]',\n  '[role=\"radio\"]',\n  '[role=\"slider\"]',\n  '[role=\"switch\"]',\n  '[role=\"tab\"]',\n  '[role=\"treeitem\"]',\n  '[data-analytics-interaction=\"click\"]'\n].join(',');\n\nconst EDITABLE_SELECTOR = '[contenteditable=\"\"], [contenteditable=\"true\"]';\nconst KEYBOARD_VALUE_SELECTOR = '[role=\"slider\"], [role=\"spinbutton\"]';\nconst VALUE_KEYS = new Set(['ArrowDown', 'ArrowLeft', 'ArrowRight', 'ArrowUp', 'End', 'Home', 'PageDown', 'PageUp']);\nconst NATIVE_VALUE_SELECTOR = [\n  'input:not([type=\"button\"]):not([type=\"hidden\"]):not([type=\"image\"]):not([type=\"reset\"]):not([type=\"submit\"])',\n  'select',\n  'textarea'\n].join(',');\nconst VALUE_SELECTOR = [\n  NATIVE_VALUE_SELECTOR,\n  '[role=\"checkbox\"]',\n  '[role=\"combobox\"]',\n  '[role=\"listbox\"]',\n  '[role=\"radio\"]',\n  '[role=\"slider\"]',\n  '[role=\"spinbutton\"]',\n  '[role=\"switch\"]',\n  '[data-analytics-interaction=\"change\"]'\n].join(',');\n\nconst findTarget = (event: Event, selector: string): Element | undefined => {\n  const path = typeof event.composedPath === 'function' ? event.composedPath() : [event.target];\n\n  return path.find((item): item is Element => item instanceof Element && item.matches(selector));\n};\n\nconst getControl = (element: Element): string => {\n  const role = element.getAttribute('role');\n\n  if(role) {\n    return role;\n  }\n\n  if(element instanceof HTMLInputElement) {\n    return `input.${element.type || 'text'}`;\n  }\n\n  return element.tagName.toLowerCase();\n};\n\nconst isTrackable = (element: Element): boolean => {\n  const disabled = element.getAttribute('aria-disabled') === 'true'\n    || (element instanceof HTMLButtonElement && element.disabled)\n    || (element instanceof HTMLInputElement && element.disabled)\n    || (element instanceof HTMLSelectElement && element.disabled)\n    || (element instanceof HTMLTextAreaElement && element.disabled);\n\n  return !disabled && !element.closest('[data-analytics-track=\"false\"]');\n};\n\nconst trackInteraction = (awsRum: AwsRum, element: Element, interaction: InteractionKind): void => {\n  if(!isTrackable(element)) {\n    return;\n  }\n\n  const analyticsName = element.getAttribute('data-analytics-name')?.trim();\n\n  awsRum.track({\n    name: analyticsName || 'interaction',\n    path: globalThis.location?.pathname,\n    properties: {\n      control: getControl(element),\n      interaction\n    },\n    type: interaction === 'activate' ? 'click' : interaction\n  });\n};\n\n/**\n * Tracks semantic interactions with one delegated listener per event type.\n * Values, visible text, URLs, and query strings are deliberately excluded.\n */\nexport const registerInteractionAnalytics = (\n  awsRum: AwsRum,\n  ownerDocument: Document | undefined = globalThis.document\n): (() => void) => {\n  if(!ownerDocument) {\n    return () => {};\n  }\n\n  const handleBlur = (event: Event): void => {\n    const target = findTarget(event, EDITABLE_SELECTOR);\n\n    if(target) {\n      trackInteraction(awsRum, target, 'edit');\n    }\n  };\n  const handleChange = (event: Event): void => {\n    const target = findTarget(event, VALUE_SELECTOR);\n\n    if(target) {\n      trackInteraction(awsRum, target, 'change');\n    }\n  };\n  const handleClick = (event: Event): void => {\n    const target = findTarget(event, ACTIVATION_SELECTOR);\n\n    if(target && !target.matches(NATIVE_VALUE_SELECTOR)) {\n      trackInteraction(awsRum, target, 'activate');\n    }\n  };\n  const handleSubmit = (event: Event): void => {\n    const submitEvent = event as SubmitEvent;\n\n    if(!submitEvent.submitter && event.target instanceof HTMLFormElement) {\n      trackInteraction(awsRum, event.target, 'submit');\n    }\n  };\n  const handleValueKey = (event: Event): void => {\n    const keyboardEvent = event as KeyboardEvent;\n    const target = findTarget(event, KEYBOARD_VALUE_SELECTOR);\n\n    if(target && VALUE_KEYS.has(keyboardEvent.key)) {\n      trackInteraction(awsRum, target, 'change');\n    }\n  };\n\n  ownerDocument.addEventListener('blur', handleBlur, true);\n  ownerDocument.addEventListener('change', handleChange, true);\n  ownerDocument.addEventListener('click', handleClick, true);\n  ownerDocument.addEventListener('keyup', handleValueKey, true);\n  ownerDocument.addEventListener('submit', handleSubmit, true);\n\n  return () => {\n    ownerDocument.removeEventListener('blur', handleBlur, true);\n    ownerDocument.removeEventListener('change', handleChange, true);\n    ownerDocument.removeEventListener('click', handleClick, true);\n    ownerDocument.removeEventListener('keyup', handleValueKey, true);\n    ownerDocument.removeEventListener('submit', handleSubmit, true);\n  };\n};\n"],"names":["ACTIVATION_SELECTOR","join","EDITABLE_SELECTOR","KEYBOARD_VALUE_SELECTOR","VALUE_KEYS","Set","NATIVE_VALUE_SELECTOR","VALUE_SELECTOR","findTarget","event","selector","path","composedPath","target","find","item","Element","matches","getControl","element","role","getAttribute","HTMLInputElement","type","tagName","toLowerCase","isTrackable","disabled","HTMLButtonElement","HTMLSelectElement","HTMLTextAreaElement","closest","trackInteraction","awsRum","interaction","analyticsName","trim","track","name","globalThis","location","pathname","properties","control","registerInteractionAnalytics","ownerDocument","document","handleBlur","handleChange","handleClick","handleSubmit","submitEvent","submitter","HTMLFormElement","handleValueKey","keyboardEvent","has","key","addEventListener","removeEventListener"],"mappings":"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"}

package/lib/utils/navEventQueue.d.ts

@@ -0,0 +1,6 @@
+type Handler = (data: any) => void;
+export declare const enqueue: (type: string, data: any) => void;
+export declare const registerHandler: (type: string, handler: Handler) => void;
+export declare const clear: () => void;
+export declare const registerFlux: (flux: any) => void;
+export {};

package/lib/utils/navEventQueue.js

@@ -0,0 +1,50 @@
+import { GothamConstants } from '../constants/GothamConstants.js';
+const queue = new Map();
+const handlers = new Map();
+export const enqueue = (type, data)=>{
+    const list = queue.get(type) || [];
+    list.push(data);
+    queue.set(type, list);
+};
+export const registerHandler = (type, handler)=>{
+    handlers.set(type, handler);
+    const queued = queue.get(type);
+    if (queued && queued.length) {
+        // Flush queued items
+        queued.forEach((item)=>{
+            try {
+                handler(item);
+            } catch (e) {
+            // swallow errors to avoid breaking app init
+            }
+        });
+        queue.delete(type);
+    }
+};
+export const clear = ()=>{
+    queue.clear();
+    handlers.clear();
+};
+export const registerFlux = (flux)=>{
+    if (!flux || typeof flux.on !== 'function') {
+        return;
+    }
+    const capture = (type)=>(data)=>{
+            const handler = handlers.get(type);
+            if (handler) {
+                try {
+                    handler(data);
+                } catch (e) {
+                // ignore
+                }
+            } else {
+                enqueue(type, data);
+            }
+        };
+    flux.on(GothamConstants.NAV_GOTO, capture(GothamConstants.NAV_GOTO));
+    flux.on(GothamConstants.NAV_REPLACE, capture(GothamConstants.NAV_REPLACE));
+    flux.on(GothamConstants.NAV_BACK, capture(GothamConstants.NAV_BACK));
+    flux.on(GothamConstants.NAV_FORWARD, capture(GothamConstants.NAV_FORWARD));
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/refUtils.d.ts

@@ -0,0 +1,2 @@
+import type { Ref } from 'react';
+export declare const assignRef: <T>(ref: Ref<T> | undefined, value: T | null) => void;

package/lib/utils/refUtils.js

@@ -0,0 +1,11 @@
+export const assignRef = (ref, value)=>{
+    if (typeof ref === 'function') {
+        ref(value);
+        return;
+    }
+    if (ref) {
+        ref.current = value;
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L2dvdGhhbWpzL3NyYy91dGlscy9yZWZVdGlscy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7UmVmfSBmcm9tICdyZWFjdCc7XG5cbmV4cG9ydCBjb25zdCBhc3NpZ25SZWYgPSA8VD4ocmVmOiBSZWY8VD4gfCB1bmRlZmluZWQsIHZhbHVlOiBUIHwgbnVsbCk6IHZvaWQgPT4ge1xuICBpZih0eXBlb2YgcmVmID09PSAnZnVuY3Rpb24nKSB7XG4gICAgcmVmKHZhbHVlKTtcbiAgICByZXR1cm47XG4gIH1cblxuICBpZihyZWYpIHtcbiAgICByZWYuY3VycmVudCA9IHZhbHVlO1xuICB9XG59O1xuIl0sIm5hbWVzIjpbImFzc2lnblJlZiIsInJlZiIsInZhbHVlIiwiY3VycmVudCJdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxNQUFNQSxZQUFZLENBQUlDLEtBQXlCQztJQUNwRCxJQUFHLE9BQU9ELFFBQVEsWUFBWTtRQUM1QkEsSUFBSUM7UUFDSjtJQUNGO0lBRUEsSUFBR0QsS0FBSztRQUNOQSxJQUFJRSxPQUFPLEdBQUdEO0lBQ2hCO0FBQ0YsRUFBRSJ9

package/lib/utils/routeUtils.d.ts

@@ -0,0 +1,12 @@
+import type { RouteObject } from 'react-router';
+export type CustomRouteProps = RouteObject & {
+    readonly analytics?: {
+        readonly route?: string;
+        readonly title?: string;
+        readonly viewId: string;
+    };
+    readonly authenticate?: boolean;
+    readonly props?: Record<string, unknown>;
+    readonly routes?: CustomRouteProps[];
+};
+export declare const parseRoutes: (routes?: CustomRouteProps[], parentPath?: string) => RouteObject[];

package/lib/utils/routeUtils.js

@@ -0,0 +1,109 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { Flux } from '@nlabs/arkhamjs';
+import React from 'react';
+import { Outlet, redirect } from 'react-router';
+import { AuthRoute } from '../components/AuthRoute/AuthRoute.js';
+import { Config } from '../config/appConfig.js';
+export const parseRoutes = (routes = [], parentPath = '')=>routes.map((route)=>{
+        const { analytics, authenticate, element, props, ...standardRouteProps } = route;
+        const nestedRoutes = route.routes || route.children;
+        const currentPath = typeof standardRouteProps.path === 'string' ? standardRouteProps.path.replace(/^\//, '') : '';
+        const fullPath = parentPath ? parentPath + (currentPath ? `/${currentPath}` : '') : currentPath;
+        const authRoute = Config.get('authRoute') || '/signIn';
+        let routeElement = element;
+        if (/*#__PURE__*/ React.isValidElement(element)) {
+            routeElement = /*#__PURE__*/ React.cloneElement(element, {
+                route
+            });
+        } else if (typeof element === 'function' || element !== null && typeof element === 'object' && '$$typeof' in element && element.$$typeof === Symbol.for('react.memo')) {
+            routeElement = /*#__PURE__*/ React.createElement(element, {
+                route
+            });
+        }
+        let authFlag = authenticate;
+        if (authFlag === undefined && /*#__PURE__*/ React.isValidElement(element)) {
+            const elemProps = element.props;
+            authFlag = Boolean(elemProps && (elemProps.authenticate || elemProps.route && elemProps.route.authenticate));
+        }
+        if (authFlag) {
+            if (!routeElement) {
+                routeElement = /*#__PURE__*/ _jsx(AuthRoute, {
+                    children: /*#__PURE__*/ _jsx(Outlet, {})
+                });
+            } else {
+                routeElement = /*#__PURE__*/ _jsx(AuthRoute, {
+                    children: routeElement
+                });
+            }
+        }
+        const normalizedChildren = nestedRoutes?.length ? nestedRoutes.map((child)=>{
+            let childPath = typeof child.path === 'string' ? child.path.replace(/^\/*/, '') : child.path;
+            if (fullPath && typeof childPath === 'string') {
+                const prefix = `${fullPath}/`;
+                if (childPath.startsWith(prefix)) {
+                    childPath = childPath.replace(new RegExp(`^${prefix}`), '');
+                }
+            }
+            return {
+                ...child,
+                path: childPath
+            };
+        }) : undefined;
+        const loader = route.loader || (authFlag ? makeRequireAuthLoader(authRoute) : undefined);
+        const handle = analytics ? {
+            ...standardRouteProps.handle || {},
+            analytics
+        } : standardRouteProps.handle;
+        if (normalizedChildren?.length) {
+            return {
+                ...standardRouteProps,
+                authenticate: authFlag,
+                children: parseRoutes(normalizedChildren, fullPath),
+                element: routeElement,
+                handle,
+                loader,
+                path: currentPath || standardRouteProps.path
+            };
+        }
+        return {
+            ...standardRouteProps,
+            authenticate: authFlag,
+            element: routeElement,
+            handle,
+            loader,
+            path: currentPath || standardRouteProps.path
+        };
+    });
+const makeRequireAuthLoader = (authRoute)=>async ({ request })=>{
+        let token;
+        try {
+            if (Flux && typeof Flux.getState === 'function') {
+                token = Flux.getState([
+                    'user',
+                    'session',
+                    'token'
+                ]) || Flux.getState([
+                    'session',
+                    'token'
+                ]) || Flux.getState([
+                    'user',
+                    'token'
+                ]);
+            }
+        } catch (_e) {
+        // ignore errors accessing Flux
+        }
+        const isAuthFn = Config.get('isAuth', ()=>false);
+        const sessionAuth = Boolean(token) || isAuthFn && isAuthFn();
+        if (!sessionAuth) {
+            const url = new URL(request.url);
+            const redirectParam = encodeURIComponent(`${url.pathname}${url.search}${url.hash}`);
+            return redirect(`${authRoute}?redirect=${redirectParam}`);
+        }
+        return null;
+    };
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/gothamjs/src/utils/routeUtils.tsx"],"sourcesContent":["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {Flux} from '@nlabs/arkhamjs';\nimport React from 'react';\nimport {Outlet, redirect} from 'react-router';\n\nimport {AuthRoute} from '../components/AuthRoute/AuthRoute.js';\nimport {Config} from '../config/appConfig.js';\n\nimport type {RouteObject} from 'react-router';\n\n\n// Define a type for our custom route objects\nexport type CustomRouteProps = RouteObject & {\n  readonly analytics?: {\n    readonly route?: string;\n    readonly title?: string;\n    readonly viewId: string;\n  };\n  readonly authenticate?: boolean;\n  readonly props?: Record<string, unknown>;\n  readonly routes?: CustomRouteProps[];\n}\n\nexport const parseRoutes = (routes: CustomRouteProps[] = [], parentPath = ''): RouteObject[] => routes.map((route) => {\n  const {\n    analytics,\n    authenticate,\n    element,\n    props,\n    ...standardRouteProps\n  } = route;\n\n  const nestedRoutes = (route as any).routes || (route as any).children;\n  const currentPath = typeof standardRouteProps.path === 'string'\n    ? standardRouteProps.path.replace(/^\\//, '')\n    : '';\n  const fullPath = parentPath ? (parentPath + (currentPath ? `/${currentPath}` : '')) : currentPath;\n  const authRoute = (Config.get('authRoute') as string) || '/signIn';\n  let routeElement = element;\n\n  if(React.isValidElement(element)) {\n    routeElement = React.cloneElement(element, {route} as any);\n  } else if(typeof element === 'function' || (\n    element !== null\n    && typeof element === 'object'\n    && '$$typeof' in element\n    && element.$$typeof === Symbol.for('react.memo')\n  )) {\n    routeElement = React.createElement(element as any, {route});\n  }\n\n  let authFlag = authenticate;\n\n  if(authFlag === undefined && React.isValidElement(element)) {\n    const elemProps: any = (element as React.ReactElement).props;\n    authFlag = Boolean(elemProps && (elemProps.authenticate || (elemProps.route && elemProps.route.authenticate)));\n  }\n\n  if(authFlag) {\n    if(!routeElement) {\n      routeElement = <AuthRoute><Outlet/></AuthRoute>;\n    } else {\n      routeElement = <AuthRoute>{routeElement}</AuthRoute>;\n    }\n  }\n\n  const normalizedChildren = nestedRoutes?.length\n    ? nestedRoutes.map((child) => {\n      let childPath = typeof child.path === 'string' ? child.path.replace(/^\\/*/, '') : child.path;\n\n      if(fullPath && typeof childPath === 'string') {\n        const prefix = `${fullPath}/`;\n        if(childPath.startsWith(prefix)) {\n          childPath = childPath.replace(new RegExp(`^${prefix}`), '');\n        }\n      }\n\n      return {\n        ...child,\n        path: childPath\n      };\n    })\n    : undefined;\n\n  const loader = (route as any).loader || (authFlag ? makeRequireAuthLoader(authRoute) : undefined);\n  const handle = analytics ? {...(standardRouteProps.handle || {}), analytics} : standardRouteProps.handle;\n\n  if(normalizedChildren?.length) {\n    return {\n      ...standardRouteProps,\n      authenticate: authFlag,\n      children: parseRoutes(normalizedChildren as CustomRouteProps[], fullPath),\n      element: routeElement,\n      handle,\n      loader,\n      path: currentPath || standardRouteProps.path\n    } as any;\n  }\n\n  return {\n    ...standardRouteProps,\n    authenticate: authFlag,\n    element: routeElement,\n    handle,\n    loader,\n    path: currentPath || standardRouteProps.path\n  } as any;\n});\n\nconst makeRequireAuthLoader = (authRoute: string): any => async ({request}: {request: Request}) => {\n  let token: string | undefined;\n\n  try {\n    if(Flux && typeof Flux.getState === 'function') {\n      token = Flux.getState(['user', 'session', 'token']) as string || Flux.getState(['session', 'token']) as string || Flux.getState(['user', 'token']) as string;\n    }\n  } catch(_e) {\n    // ignore errors accessing Flux\n  }\n\n  const isAuthFn = Config.get('isAuth', () => false) as () => boolean;\n  const sessionAuth = Boolean(token) || (isAuthFn && isAuthFn());\n\n  if(!sessionAuth) {\n    const url = new URL(request.url);\n    const redirectParam = encodeURIComponent(`${url.pathname}${url.search}${url.hash}`);\n\n    return redirect(`${authRoute}?redirect=${redirectParam}`);\n  }\n\n  return null;\n};\n"],"names":["Flux","React","Outlet","redirect","AuthRoute","Config","parseRoutes","routes","parentPath","map","route","analytics","authenticate","element","props","standardRouteProps","nestedRoutes","children","currentPath","path","replace","fullPath","authRoute","get","routeElement","isValidElement","cloneElement","$$typeof","Symbol","for","createElement","authFlag","undefined","elemProps","Boolean","normalizedChildren","length","child","childPath","prefix","startsWith","RegExp","loader","makeRequireAuthLoader","handle","request","token","getState","_e","isAuthFn","sessionAuth","url","URL","redirectParam","encodeURIComponent","pathname","search","hash"],"mappings":"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"}

package/lib/utils/sizeUtils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+export type GothamSize = 'sm' | 'md' | 'lg';

package/lib/utils/sizeUtils.js

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ export { };
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L2dvdGhhbWpzL3NyYy91dGlscy9zaXplVXRpbHMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTgtUHJlc2VudCwgTml0cm9nZW4gTGFicywgSW5jLlxuICogQ29weXJpZ2h0cyBsaWNlbnNlZCB1bmRlciB0aGUgTUlUIExpY2Vuc2UuIFNlZSB0aGUgYWNjb21wYW55aW5nIExJQ0VOU0UgZmlsZSBmb3IgdGVybXMuXG4gKi9cbmV4cG9ydCB0eXBlIEdvdGhhbVNpemUgPSAnc20nIHwgJ21kJyB8ICdsZyc7Il0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Q0FHQyxHQUNELFdBQTRDIn0=

package/lib/utils/storyInteractions.d.ts

@@ -0,0 +1,6 @@
+type StoryContext = {
+    readonly canvasElement: HTMLElement;
+};
+export declare const interactWithCanvas: ({ canvasElement }: StoryContext) => Promise<void>;
+export declare const focusCanvas: ({ canvasElement }: StoryContext) => Promise<void>;
+export {};

package/lib/utils/storyInteractions.js

@@ -0,0 +1,45 @@
+const preventAnchorNavigation = (element)=>{
+    const anchor = element.closest('a[href]');
+    if (anchor instanceof HTMLAnchorElement) {
+        anchor.addEventListener('click', (event)=>event.preventDefault(), {
+            capture: true,
+            once: true
+        });
+    }
+};
+const clearCanvasFocus = (canvasElement)=>{
+    const { activeElement } = canvasElement.ownerDocument;
+    if (activeElement instanceof HTMLElement && canvasElement.contains(activeElement)) {
+        activeElement.blur();
+    }
+};
+export const interactWithCanvas = async ({ canvasElement })=>{
+    await Promise.resolve();
+    const field = canvasElement.querySelector('input:not([type="file"]), textarea');
+    if (field && !field.disabled && !field.readOnly) {
+        field.focus();
+        field.value = field instanceof HTMLTextAreaElement ? 'Story interaction note' : 'Story interaction';
+        field.dispatchEvent(new Event('input', {
+            bubbles: true
+        }));
+        field.dispatchEvent(new Event('change', {
+            bubbles: true
+        }));
+        field.blur();
+    }
+    const clickable = canvasElement.querySelector('button:not([disabled]), a[href], [role="button"]');
+    if (clickable) {
+        clickable.focus();
+        preventAnchorNavigation(clickable);
+        clickable.click();
+        clearCanvasFocus(canvasElement);
+    }
+};
+export const focusCanvas = async ({ canvasElement })=>{
+    await Promise.resolve();
+    const focusable = canvasElement.querySelector('button, a[href], input, textarea, [tabindex]');
+    focusable?.focus();
+    clearCanvasFocus(canvasElement);
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L2dvdGhhbWpzL3NyYy91dGlscy9zdG9yeUludGVyYWN0aW9ucy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJ0eXBlIFN0b3J5Q29udGV4dCA9IHtcbiAgcmVhZG9ubHkgY2FudmFzRWxlbWVudDogSFRNTEVsZW1lbnQ7XG59O1xuXG5jb25zdCBwcmV2ZW50QW5jaG9yTmF2aWdhdGlvbiA9IChlbGVtZW50OiBIVE1MRWxlbWVudCkgPT4ge1xuICBjb25zdCBhbmNob3IgPSBlbGVtZW50LmNsb3Nlc3QoJ2FbaHJlZl0nKTtcblxuICBpZihhbmNob3IgaW5zdGFuY2VvZiBIVE1MQW5jaG9yRWxlbWVudCkge1xuICAgIGFuY2hvci5hZGRFdmVudExpc3RlbmVyKCdjbGljaycsIChldmVudCkgPT4gZXZlbnQucHJldmVudERlZmF1bHQoKSwge2NhcHR1cmU6IHRydWUsIG9uY2U6IHRydWV9KTtcbiAgfVxufTtcblxuY29uc3QgY2xlYXJDYW52YXNGb2N1cyA9IChjYW52YXNFbGVtZW50OiBIVE1MRWxlbWVudCkgPT4ge1xuICBjb25zdCB7YWN0aXZlRWxlbWVudH0gPSBjYW52YXNFbGVtZW50Lm93bmVyRG9jdW1lbnQ7XG5cbiAgaWYoYWN0aXZlRWxlbWVudCBpbnN0YW5jZW9mIEhUTUxFbGVtZW50ICYmIGNhbnZhc0VsZW1lbnQuY29udGFpbnMoYWN0aXZlRWxlbWVudCkpIHtcbiAgICBhY3RpdmVFbGVtZW50LmJsdXIoKTtcbiAgfVxufTtcblxuZXhwb3J0IGNvbnN0IGludGVyYWN0V2l0aENhbnZhcyA9IGFzeW5jICh7Y2FudmFzRWxlbWVudH06IFN0b3J5Q29udGV4dCkgPT4ge1xuICBhd2FpdCBQcm9taXNlLnJlc29sdmUoKTtcblxuICBjb25zdCBmaWVsZCA9IGNhbnZhc0VsZW1lbnQucXVlcnlTZWxlY3RvcignaW5wdXQ6bm90KFt0eXBlPVwiZmlsZVwiXSksIHRleHRhcmVhJykgYXMgSFRNTElucHV0RWxlbWVudCB8IEhUTUxUZXh0QXJlYUVsZW1lbnQgfCBudWxsO1xuXG4gIGlmKGZpZWxkICYmICFmaWVsZC5kaXNhYmxlZCAmJiAhZmllbGQucmVhZE9ubHkpIHtcbiAgICBmaWVsZC5mb2N1cygpO1xuICAgIGZpZWxkLnZhbHVlID0gZmllbGQgaW5zdGFuY2VvZiBIVE1MVGV4dEFyZWFFbGVtZW50ID8gJ1N0b3J5IGludGVyYWN0aW9uIG5vdGUnIDogJ1N0b3J5IGludGVyYWN0aW9uJztcbiAgICBmaWVsZC5kaXNwYXRjaEV2ZW50KG5ldyBFdmVudCgnaW5wdXQnLCB7YnViYmxlczogdHJ1ZX0pKTtcbiAgICBmaWVsZC5kaXNwYXRjaEV2ZW50KG5ldyBFdmVudCgnY2hhbmdlJywge2J1YmJsZXM6IHRydWV9KSk7XG4gICAgZmllbGQuYmx1cigpO1xuICB9XG5cbiAgY29uc3QgY2xpY2thYmxlID0gY2FudmFzRWxlbWVudC5xdWVyeVNlbGVjdG9yKCdidXR0b246bm90KFtkaXNhYmxlZF0pLCBhW2hyZWZdLCBbcm9sZT1cImJ1dHRvblwiXScpIGFzIEhUTUxFbGVtZW50IHwgbnVsbDtcblxuICBpZihjbGlja2FibGUpIHtcbiAgICBjbGlja2FibGUuZm9jdXMoKTtcbiAgICBwcmV2ZW50QW5jaG9yTmF2aWdhdGlvbihjbGlja2FibGUpO1xuICAgIGNsaWNrYWJsZS5jbGljaygpO1xuICAgIGNsZWFyQ2FudmFzRm9jdXMoY2FudmFzRWxlbWVudCk7XG4gIH1cbn07XG5cbmV4cG9ydCBjb25zdCBmb2N1c0NhbnZhcyA9IGFzeW5jICh7Y2FudmFzRWxlbWVudH06IFN0b3J5Q29udGV4dCkgPT4ge1xuICBhd2FpdCBQcm9taXNlLnJlc29sdmUoKTtcblxuICBjb25zdCBmb2N1c2FibGUgPSBjYW52YXNFbGVtZW50LnF1ZXJ5U2VsZWN0b3IoJ2J1dHRvbiwgYVtocmVmXSwgaW5wdXQsIHRleHRhcmVhLCBbdGFiaW5kZXhdJykgYXMgSFRNTEVsZW1lbnQgfCBudWxsO1xuICBmb2N1c2FibGU/LmZvY3VzKCk7XG4gIGNsZWFyQ2FudmFzRm9jdXMoY2FudmFzRWxlbWVudCk7XG59O1xuIl0sIm5hbWVzIjpbInByZXZlbnRBbmNob3JOYXZpZ2F0aW9uIiwiZWxlbWVudCIsImFuY2hvciIsImNsb3Nlc3QiLCJIVE1MQW5jaG9yRWxlbWVudCIsImFkZEV2ZW50TGlzdGVuZXIiLCJldmVudCIsInByZXZlbnREZWZhdWx0IiwiY2FwdHVyZSIsIm9uY2UiLCJjbGVhckNhbnZhc0ZvY3VzIiwiY2FudmFzRWxlbWVudCIsImFjdGl2ZUVsZW1lbnQiLCJvd25lckRvY3VtZW50IiwiSFRNTEVsZW1lbnQiLCJjb250YWlucyIsImJsdXIiLCJpbnRlcmFjdFdpdGhDYW52YXMiLCJQcm9taXNlIiwicmVzb2x2ZSIsImZpZWxkIiwicXVlcnlTZWxlY3RvciIsImRpc2FibGVkIiwicmVhZE9ubHkiLCJmb2N1cyIsInZhbHVlIiwiSFRNTFRleHRBcmVhRWxlbWVudCIsImRpc3BhdGNoRXZlbnQiLCJFdmVudCIsImJ1YmJsZXMiLCJjbGlja2FibGUiLCJjbGljayIsImZvY3VzQ2FudmFzIiwiZm9jdXNhYmxlIl0sIm1hcHBpbmdzIjoiQUFJQSxNQUFNQSwwQkFBMEIsQ0FBQ0M7SUFDL0IsTUFBTUMsU0FBU0QsUUFBUUUsT0FBTyxDQUFDO0lBRS9CLElBQUdELGtCQUFrQkUsbUJBQW1CO1FBQ3RDRixPQUFPRyxnQkFBZ0IsQ0FBQyxTQUFTLENBQUNDLFFBQVVBLE1BQU1DLGNBQWMsSUFBSTtZQUFDQyxTQUFTO1lBQU1DLE1BQU07UUFBSTtJQUNoRztBQUNGO0FBRUEsTUFBTUMsbUJBQW1CLENBQUNDO0lBQ3hCLE1BQU0sRUFBQ0MsYUFBYSxFQUFDLEdBQUdELGNBQWNFLGFBQWE7SUFFbkQsSUFBR0QseUJBQXlCRSxlQUFlSCxjQUFjSSxRQUFRLENBQUNILGdCQUFnQjtRQUNoRkEsY0FBY0ksSUFBSTtJQUNwQjtBQUNGO0FBRUEsT0FBTyxNQUFNQyxxQkFBcUIsT0FBTyxFQUFDTixhQUFhLEVBQWU7SUFDcEUsTUFBTU8sUUFBUUMsT0FBTztJQUVyQixNQUFNQyxRQUFRVCxjQUFjVSxhQUFhLENBQUM7SUFFMUMsSUFBR0QsU0FBUyxDQUFDQSxNQUFNRSxRQUFRLElBQUksQ0FBQ0YsTUFBTUcsUUFBUSxFQUFFO1FBQzlDSCxNQUFNSSxLQUFLO1FBQ1hKLE1BQU1LLEtBQUssR0FBR0wsaUJBQWlCTSxzQkFBc0IsMkJBQTJCO1FBQ2hGTixNQUFNTyxhQUFhLENBQUMsSUFBSUMsTUFBTSxTQUFTO1lBQUNDLFNBQVM7UUFBSTtRQUNyRFQsTUFBTU8sYUFBYSxDQUFDLElBQUlDLE1BQU0sVUFBVTtZQUFDQyxTQUFTO1FBQUk7UUFDdERULE1BQU1KLElBQUk7SUFDWjtJQUVBLE1BQU1jLFlBQVluQixjQUFjVSxhQUFhLENBQUM7SUFFOUMsSUFBR1MsV0FBVztRQUNaQSxVQUFVTixLQUFLO1FBQ2Z4Qix3QkFBd0I4QjtRQUN4QkEsVUFBVUMsS0FBSztRQUNmckIsaUJBQWlCQztJQUNuQjtBQUNGLEVBQUU7QUFFRixPQUFPLE1BQU1xQixjQUFjLE9BQU8sRUFBQ3JCLGFBQWEsRUFBZTtJQUM3RCxNQUFNTyxRQUFRQyxPQUFPO0lBRXJCLE1BQU1jLFlBQVl0QixjQUFjVSxhQUFhLENBQUM7SUFDOUNZLFdBQVdUO0lBQ1hkLGlCQUFpQkM7QUFDbkIsRUFBRSJ9

package/lib/utils/storyUtils.d.ts

@@ -0,0 +1 @@
+export declare const gothamDecorator: (Story: any) => import("react").JSX.Element;

package/lib/utils/storyUtils.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { GothamProvider } from '../views/Gotham/GothamProvider.js';
+export const gothamDecorator = (Story)=>/*#__PURE__*/ _jsx(GothamProvider, {
+        config: {},
+        children: /*#__PURE__*/ _jsx(Story, {})
+    });
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L2dvdGhhbWpzL3NyYy91dGlscy9zdG9yeVV0aWxzLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHlyaWdodCAoYykgMjAxOC1QcmVzZW50LCBOaXRyb2dlbiBMYWJzLCBJbmMuXG4gKiBDb3B5cmlnaHRzIGxpY2Vuc2VkIHVuZGVyIHRoZSBNSVQgTGljZW5zZS4gU2VlIHRoZSBhY2NvbXBhbnlpbmcgTElDRU5TRSBmaWxlIGZvciB0ZXJtcy5cbiAqL1xuaW1wb3J0IHtHb3RoYW1Qcm92aWRlcn0gZnJvbSAnLi4vdmlld3MvR290aGFtL0dvdGhhbVByb3ZpZGVyLmpzJztcblxuZXhwb3J0IGNvbnN0IGdvdGhhbURlY29yYXRvciA9IChTdG9yeSkgPT4gKFxuICA8R290aGFtUHJvdmlkZXIgY29uZmlnPXt7fX0+XG4gICAgPFN0b3J5IC8+XG4gIDwvR290aGFtUHJvdmlkZXI+XG4pO1xuIl0sIm5hbWVzIjpbIkdvdGhhbVByb3ZpZGVyIiwiZ290aGFtRGVjb3JhdG9yIiwiU3RvcnkiLCJjb25maWciXSwibWFwcGluZ3MiOiI7QUFBQTs7O0NBR0MsR0FDRCxTQUFRQSxjQUFjLFFBQU8sb0NBQW9DO0FBRWpFLE9BQU8sTUFBTUMsa0JBQWtCLENBQUNDLHNCQUM5QixLQUFDRjtRQUFlRyxRQUFRLENBQUM7a0JBQ3ZCLGNBQUEsS0FBQ0Q7T0FFSCJ9

package/lib/utils/testUtils.d.ts

@@ -0,0 +1,3 @@
+export declare const getTestElement: (name: string, index?: number) => HTMLElement;
+export declare const renderWithProvider: any;
+export declare const renderWithForm: any;

package/lib/utils/testUtils.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { Flux } from '@nlabs/arkhamjs';
+import { FluxProvider } from '@nlabs/arkhamjs-utils-react';
+import { render, screen, waitFor } from '@nlabs/lex/test-react';
+import { MemoryRouter } from 'react-router';
+import { Form } from '../components/Form/Form.js';
+export const getTestElement = (name, index = 0)=>screen.queryAllByTestId(name)[index];
+export const renderWithProvider = async (Element, props = {})=>{
+    const { mockRoute = '/', ...restProps } = props;
+    Flux.init();
+    jest.useFakeTimers();
+    const wrapper = render(/*#__PURE__*/ _jsx(FluxProvider, {
+        flux: Flux,
+        children: /*#__PURE__*/ _jsx(MemoryRouter, {
+            initialEntries: [
+                mockRoute
+            ],
+            initialIndex: 0,
+            children: /*#__PURE__*/ _jsx(Element, {
+                ...restProps
+            })
+        })
+    }));
+    await waitFor(()=>{
+        jest.runAllImmediates();
+    });
+    return wrapper;
+};
+export const renderWithForm = async (Element, props = {})=>{
+    const { mocks, onSubmit = ()=>{}, ...restProps } = props;
+    jest.useFakeTimers();
+    const wrapper = render(/*#__PURE__*/ _jsx(FluxProvider, {
+        flux: Flux,
+        children: /*#__PURE__*/ _jsx(MemoryRouter, {
+            initialEntries: [
+                '/'
+            ],
+            initialIndex: 0,
+            children: /*#__PURE__*/ _jsx(Form, {
+                onSubmit: onSubmit,
+                children: /*#__PURE__*/ _jsx(Element, {
+                    ...restProps
+                })
+            })
+        })
+    }));
+    await waitFor(()=>{
+        jest.runAllImmediates();
+    });
+    return wrapper;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/timer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+/**
+ * Create a Timer
+ * @param {Number} delay
+ * @param {Function} callback
+ * @constructor
+ */
+export declare class GothamTimer {
+    timerId: unknown;
+    start: number;
+    remaining: number;
+    delay: number;
+    callback: unknown;
+    constructor(delay: number, callback: unknown);
+    pause(): void;
+    resume(): void;
+    getTimeRemaining(): number;
+}