@lmvz-ds/components 0.11.4

package/dist/collection/utils/component.js

@@ -0,0 +1,268 @@
+export const transitionEndAsync = (el, expectedDuration = 0) => {
+    return new Promise(resolve => {
+        transitionEnd(el, expectedDuration, resolve);
+    });
+};
+const transitionEnd = (el, expectedDuration = 0, callback) => {
+    let unRegTrans;
+    let animationTimeout;
+    const opts = { passive: true };
+    const ANIMATION_FALLBACK_TIMEOUT = 500;
+    const unregister = () => {
+        if (unRegTrans) {
+            unRegTrans();
+        }
+    };
+    const onTransitionEnd = (ev) => {
+        if (ev === undefined || el === ev.target) {
+            unregister();
+            callback(ev);
+        }
+    };
+    if (el) {
+        el.addEventListener('webkitTransitionEnd', onTransitionEnd, opts);
+        el.addEventListener('transitionend', onTransitionEnd, opts);
+        animationTimeout = setTimeout(onTransitionEnd, expectedDuration + ANIMATION_FALLBACK_TIMEOUT);
+        unRegTrans = () => {
+            if (animationTimeout !== undefined) {
+                clearTimeout(animationTimeout);
+                animationTimeout = undefined;
+            }
+            el.removeEventListener('webkitTransitionEnd', onTransitionEnd, opts);
+            el.removeEventListener('transitionend', onTransitionEnd, opts);
+        };
+    }
+    return unregister;
+};
+export const componentOnReady = (el, callback) => {
+    if (el.componentOnReady) {
+        el.componentOnReady().then((resolvedEl) => callback(resolvedEl));
+    }
+    else {
+        raf(() => callback(el));
+    }
+};
+export const hasLazyBuild = (stencilEl) => {
+    return stencilEl.componentOnReady !== undefined;
+};
+export const inheritAttributes = (el, attributes = []) => {
+    const attributeObject = {};
+    attributes.forEach(attr => {
+        if (el.hasAttribute(attr)) {
+            const value = el.getAttribute(attr);
+            if (value !== null) {
+                attributeObject[attr] = el.getAttribute(attr);
+            }
+            el.removeAttribute(attr);
+        }
+    });
+    return attributeObject;
+};
+const ariaAttributes = [
+    'role',
+    'aria-activedescendant',
+    'aria-atomic',
+    'aria-autocomplete',
+    'aria-braillelabel',
+    'aria-brailleroledescription',
+    'aria-busy',
+    'aria-checked',
+    'aria-colcount',
+    'aria-colindex',
+    'aria-colindextext',
+    'aria-colspan',
+    'aria-controls',
+    'aria-current',
+    'aria-describedby',
+    'aria-description',
+    'aria-details',
+    'aria-disabled',
+    'aria-errormessage',
+    'aria-expanded',
+    'aria-flowto',
+    'aria-haspopup',
+    'aria-hidden',
+    'aria-invalid',
+    'aria-keyshortcuts',
+    'aria-label',
+    'aria-labelledby',
+    'aria-level',
+    'aria-live',
+    'aria-multiline',
+    'aria-multiselectable',
+    'aria-orientation',
+    'aria-owns',
+    'aria-placeholder',
+    'aria-posinset',
+    'aria-pressed',
+    'aria-readonly',
+    'aria-relevant',
+    'aria-required',
+    'aria-roledescription',
+    'aria-rowcount',
+    'aria-rowindex',
+    'aria-rowindextext',
+    'aria-rowspan',
+    'aria-selected',
+    'aria-setsize',
+    'aria-sort',
+    'aria-valuemax',
+    'aria-valuemin',
+    'aria-valuenow',
+    'aria-valuetext',
+];
+export const inheritAriaAttributes = (el, ignoreList) => {
+    let attributesToInherit = ariaAttributes;
+    if (ignoreList && ignoreList.length > 0) {
+        attributesToInherit = attributesToInherit.filter(attr => !ignoreList.includes(attr));
+    }
+    return inheritAttributes(el, attributesToInherit);
+};
+export const addEventListener = (el, eventName, callback, opts) => {
+    return el.addEventListener(eventName, callback, opts);
+};
+export const removeEventListener = (el, eventName, callback, opts) => {
+    return el.removeEventListener(eventName, callback, opts);
+};
+export const getElementRoot = (el, fallback = el) => {
+    return el.shadowRoot || fallback;
+};
+export const raf = (h) => {
+    if (typeof __zone_symbol__requestAnimationFrame === 'function') {
+        return __zone_symbol__requestAnimationFrame(h);
+    }
+    if (typeof requestAnimationFrame === 'function') {
+        return requestAnimationFrame(h);
+    }
+    return setTimeout(h);
+};
+export const hasShadowDom = (el) => {
+    return !!el.shadowRoot && !!el.attachShadow;
+};
+export const focusVisibleElement = (el) => {
+    el.focus();
+};
+export const renderHiddenInput = (always, container, name, value, disabled) => {
+    if (always || hasShadowDom(container)) {
+        let input = container.querySelector('input.aux-input');
+        if (!input) {
+            input = container.ownerDocument.createElement('input');
+            input.type = 'hidden';
+            input.classList.add('aux-input');
+            container.appendChild(input);
+        }
+        input.disabled = disabled;
+        input.name = name;
+        input.value = value || '';
+    }
+};
+export const clamp = (min, n, max) => {
+    return Math.max(min, Math.min(n, max));
+};
+export const assert = (actual, reason) => {
+    if (!actual) {
+        const message = 'ASSERT: ' + reason;
+        console.error(message);
+        debugger;
+        throw new Error(message);
+    }
+};
+export const now = (ev) => {
+    return ev.timeStamp || Date.now();
+};
+export const pointerCoord = (ev) => {
+    if (ev) {
+        const changedTouches = ev.changedTouches;
+        if (changedTouches && changedTouches.length > 0) {
+            const touch = changedTouches[0];
+            return { x: touch.clientX, y: touch.clientY };
+        }
+        if (ev.pageX !== undefined) {
+            return { x: ev.pageX, y: ev.pageY };
+        }
+    }
+    return { x: 0, y: 0 };
+};
+export const deferEvent = (event) => {
+    return debounceEvent(event, 0);
+};
+export const debounceEvent = (event, wait) => {
+    const original = event._original || event;
+    return {
+        _original: event,
+        emit: debounce(original.emit.bind(original), wait),
+    };
+};
+export const debounce = (func, wait = 0) => {
+    let timer;
+    return (...args) => {
+        clearTimeout(timer);
+        timer = setTimeout(func, wait, ...args);
+    };
+};
+export const shallowEqualStringMap = (map1, map2) => {
+    map1 ??= {};
+    map2 ??= {};
+    if (map1 === map2) {
+        return true;
+    }
+    const keys1 = Object.keys(map1);
+    if (keys1.length !== Object.keys(map2).length) {
+        return false;
+    }
+    for (const k1 of keys1) {
+        if (!(k1 in map2)) {
+            return false;
+        }
+        if (map1[k1] !== map2[k1]) {
+            return false;
+        }
+    }
+    return true;
+};
+export const isSafeNumber = (input) => {
+    return typeof input === 'number' && !isNaN(input) && isFinite(input);
+};
+export function getDeepActiveElement(root = document) {
+    let activeElement = root.activeElement;
+    if (!activeElement) {
+        return null;
+    }
+    while (activeElement && activeElement.shadowRoot) {
+        const next = activeElement.shadowRoot.activeElement;
+        if (!next) {
+            break;
+        }
+        activeElement = next;
+    }
+    return activeElement;
+}
+export function canReceiveFocus(el) {
+    return (el instanceof HTMLElement && el.tabIndex >= 0 && !el.hasAttribute('disabled') && el.getAttribute('aria-hidden') !== 'true' && el.checkVisibility() && el.offsetParent !== null);
+}
+export function findFormByRef(form, el) {
+    if (form instanceof HTMLFormElement) {
+        return form;
+    }
+    if (typeof form === 'string') {
+        const el = document.getElementById(form);
+        if (el) {
+            if (el instanceof HTMLFormElement) {
+                return el;
+            }
+            else {
+                console.warn(`No Form found with selector: "#${form}". Verify that the element with id exists and is actually a <form> element.`, el);
+                return null;
+            }
+        }
+        else {
+            console.warn(`No Form found with selector: "#${form}". Verify that the id is correct and the form is rendered in the DOM.`, el);
+            return null;
+        }
+    }
+    if (form !== undefined) {
+        console.warn(`The provided "form" element is invalid. Verify that the form is a HTMLFormElement and rendered in the DOM.`, el);
+        return null;
+    }
+    return el.closest('form');
+}

package/dist/collection/utils/effect.js

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+export function run(effect) {
+    return Effect.runPromise(effect).catch(error => {
+        console.error('Unhandled error in Effect:', error);
+    });
+}

package/dist/collection/utils/element-activation-controller.js

@@ -0,0 +1,27 @@
+export class ElementActivationController {
+    host;
+    config;
+    constructor(host, config) {
+        this.host = host;
+        this.config = config;
+    }
+    hostDidLoad() {
+        if (!this.host.el.hasAttribute('tabindex')) {
+            console.warn('Interactive element does not have a tabindex attribute!', this.host.el);
+        }
+        this.host.el.addEventListener('keydown', this.handleKeyDown.bind(this));
+        this.host.el.addEventListener('click', this.handleActivation.bind(this));
+    }
+    handleKeyDown = (event) => {
+        if ((this.config?.keys ?? ['Enter', ' ']).includes(event.key)) {
+            event.preventDefault();
+            this.handleActivation(event);
+        }
+    };
+    handleActivation = (event) => {
+        this.host.lmvzActivation.emit();
+        if (this.config?.localHandler) {
+            this.config.localHandler(event);
+        }
+    };
+}

package/dist/collection/utils/http.js

@@ -0,0 +1,24 @@
+import { Data, Effect } from "effect";
+export class FetchError extends Data.TaggedError('FetchError') {
+}
+export class NotFoundError extends Data.TaggedError('NotFoundError') {
+}
+export const httpClient = (input, init) => Effect.gen(function* () {
+    const response = yield* Effect.tryPromise({
+        try: () => fetch(input, init),
+        catch: error => new FetchError({ cause: error }),
+    });
+    if (response.status === 404) {
+        return yield* new NotFoundError({ url: response.url });
+    }
+    return response;
+});
+export class ResponseTextError extends Data.TaggedError('ResponseTextError') {
+    constructor(error) {
+        super(new Error(`Failed to read response text`, { cause: error }));
+    }
+}
+export const responseAsText = (res) => Effect.tryPromise({
+    try: () => res.text(),
+    catch: error => new ResponseTextError(error),
+});

package/dist/collection/utils/http.test.js

@@ -0,0 +1,46 @@
+import { Effect } from "effect";
+import { FetchError, NotFoundError, ResponseTextError, httpClient, responseAsText } from "./http";
+describe('Http Utils', () => {
+    describe('httpClient', () => {
+        it('should return response on successful fetch', async () => {
+            const mockResponse = { status: 200, url: 'https://example.com' };
+            global.fetch = jest.fn().mockResolvedValueOnce(mockResponse);
+            const result = await Effect.runPromise(httpClient('https://example.com'));
+            expect(result).toEqual(mockResponse);
+        });
+        it('should handle fetch errors', async () => {
+            const error = new Error('Network error');
+            global.fetch = jest.fn().mockRejectedValueOnce(error);
+            const result = await Effect.runPromise(Effect.flip(httpClient('https://example.com')));
+            expect(result).toBeInstanceOf(FetchError);
+            expect(result.cause).toBe(error);
+        });
+        it('should return NotFoundError on 404 status', async () => {
+            const mockResponse = { status: 404, url: 'https://example.com/notfound' };
+            global.fetch = jest.fn().mockResolvedValueOnce(mockResponse);
+            const result = await Effect.runPromise(Effect.flip(httpClient('https://example.com/notfound')));
+            expect(result).toBeInstanceOf(NotFoundError);
+        });
+        it('should pass RequestInit options to fetch', async () => {
+            const mockResponse = { status: 200, url: 'https://example.com' };
+            global.fetch = jest.fn().mockResolvedValueOnce(mockResponse);
+            const init = { method: 'POST', headers: { 'Content-Type': 'application/json' } };
+            await Effect.runPromise(httpClient('https://example.com', init));
+            expect(global.fetch).toHaveBeenCalledWith('https://example.com', init);
+        });
+    });
+    describe('responseAsText', () => {
+        it('should return text from response', async () => {
+            const mockResponse = { text: jest.fn().mockResolvedValueOnce('Hello World') };
+            const result = await Effect.runPromise(responseAsText(mockResponse));
+            expect(result).toBe('Hello World');
+        });
+        it('should handle text reading errors', async () => {
+            const error = new Error('Read error');
+            const mockResponse = { text: jest.fn().mockRejectedValueOnce(error) };
+            const result = await Effect.runPromise(Effect.flip(responseAsText(mockResponse)));
+            expect(result).toBeInstanceOf(ResponseTextError);
+            expect(result.message).toContain('Failed to read response text');
+        });
+    });
+});

package/dist/collection/utils/list-keyboard-controller.js

@@ -0,0 +1,44 @@
+import { canReceiveFocus, getDeepActiveElement } from "./component";
+export class ListKeyboardNavigationController {
+    host;
+    elements = [];
+    constructor(host) {
+        this.host = host;
+    }
+    hostDidRender() {
+        this.host.el.addEventListener('keydown', this.handleKeydown);
+    }
+    updateElements(elements) {
+        this.elements = elements;
+    }
+    handleKeydown = (event) => {
+        const { key } = event;
+        if (!['ArrowDown', 'ArrowRight', 'ArrowUp', 'ArrowLeft'].includes(key))
+            return;
+        const activeElement = getDeepActiveElement(document);
+        const nextElement = this.getNextFocusableElement(activeElement, ['ArrowDown', 'ArrowRight'].includes(key) ? 'down' : 'up');
+        if (nextElement) {
+            event.preventDefault();
+            nextElement.focus?.();
+        }
+    };
+    getNextFocusableElement(current, direction) {
+        const { elements } = this;
+        const currentIndex = elements.indexOf(current);
+        if (currentIndex === -1)
+            return null;
+        let nextIndex = null;
+        if (direction === 'down') {
+            nextIndex = (currentIndex + 1) % elements.length;
+        }
+        else if (direction === 'up') {
+            nextIndex = (currentIndex - 1 + elements.length) % elements.length;
+        }
+        if (nextIndex == null)
+            return null;
+        const candidate = elements[nextIndex];
+        if (!canReceiveFocus(candidate))
+            return this.getNextFocusableElement(candidate, direction);
+        return candidate;
+    }
+}

package/dist/collection/utils/public.js

@@ -0,0 +1 @@
+export { run } from './effect';

package/dist/collection/utils/reactive-controller-host.js

@@ -0,0 +1,39 @@
+export class ReactiveControllerHost {
+    controllers = new Set();
+    addController(controller) {
+        this.controllers.add(controller);
+    }
+    removeController(controller) {
+        this.controllers.delete(controller);
+    }
+    get activeControllers() {
+        return Array.from(this.controllers).filter(controller => !controller.disabled);
+    }
+    connectedCallback() {
+        if (!this.controllers.size) {
+            console.warn('ReactiveControllerHost connected with no controllers registered.', this);
+        }
+        this.activeControllers.forEach(controller => controller.hostConnected?.());
+    }
+    disconnectedCallback() {
+        this.activeControllers.forEach(controller => controller.hostDisconnected?.());
+    }
+    componentWillLoad() {
+        this.activeControllers.forEach(controller => controller.hostWillLoad?.());
+    }
+    componentDidLoad() {
+        this.activeControllers.forEach(controller => controller.hostDidLoad?.());
+    }
+    componentWillRender() {
+        this.activeControllers.forEach(controller => controller.hostWillRender?.());
+    }
+    componentDidRender() {
+        this.activeControllers.forEach(controller => controller.hostDidRender?.());
+    }
+    componentWillUpdate() {
+        this.activeControllers.forEach(controller => controller.hostWillUpdate?.());
+    }
+    componentDidUpdate() {
+        this.activeControllers.forEach(controller => controller.hostDidUpdate?.());
+    }
+}

package/dist/collection/utils/typing.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/utils/url.js

@@ -0,0 +1,7 @@
+import { getAssetPath } from "@stencil/core";
+import { Data, Effect } from "effect";
+export class URLCreationError extends Data.TaggedError('URLCreationError') {
+}
+export const createAssetUrlWithBasePath = (file, basePath) => Effect.try(() => getAssetPath([basePath ?? '/assets', file].filter(Boolean).join('/').replace('//', '/'))).pipe(Effect.tapError(() => Effect.logWarning(`Failed to create URL for icon "${file}".
+           Please provide an absolute URL in your app's 'setAssetPath(...)' configuration!
+           Falling back to /assets/`)), Effect.orElseSucceed(() => window.location.origin + '/assets/' + file));

package/dist/collection/utils/validation/aria-validation-controller.js

@@ -0,0 +1,124 @@
+import { Build } from "@stencil/core";
+import { Effect, Queue, Stream } from "effect";
+export class AriaValidationController {
+    host;
+    config;
+    static get globalValidationEnabled() {
+        return Build.isDev;
+    }
+    static axe = this.globalValidationEnabled ? import('axe-core') : null;
+    static axeQueue = null;
+    static axeStreamFiber = null;
+    visibilityObserver;
+    elementQueued = false;
+    elementValidated = false;
+    knownValidationErrors = [];
+    get disabled() {
+        return !AriaValidationController.globalValidationEnabled;
+    }
+    constructor(host, config) {
+        this.host = host;
+        this.config = config;
+        AriaValidationController.initializeAxeStream();
+    }
+    static initializeAxeStream() {
+        if (!this.globalValidationEnabled)
+            return;
+        if (this.axeStreamFiber)
+            return;
+        const program = Effect.gen(function* () {
+            const queue = (AriaValidationController.axeQueue = yield* Queue.bounded(100));
+            const axeLib = yield* Effect.promise(() => AriaValidationController.axe);
+            if (!axeLib) {
+                console.error('Axe library not available, ARIA validation will not run.');
+                return;
+            }
+            const stream = Stream.fromQueue(queue).pipe(Stream.mapEffect(({ context, onComplete }) => Effect.async(resume => {
+                axeLib.run(context, {}, (error, results) => {
+                    onComplete(error, results);
+                    resume(Effect.void);
+                });
+            })));
+            yield* Stream.runDrain(stream);
+        });
+        this.axeStreamFiber = Effect.runFork(program);
+    }
+    hostDidLoad() {
+        if (this.elementQueued || this.elementValidated)
+            return;
+        if (!this.host.el.checkVisibility()) {
+            this.observeVisibilityOnce();
+            return;
+        }
+        this.enqueueValidation();
+    }
+    hostDidUpdate() {
+        this.checkLazyValidation();
+    }
+    hostDisconnected() {
+        this.discardVisibilityObserver();
+    }
+    observeVisibilityOnce() {
+        this.visibilityObserver = new IntersectionObserver(entries => {
+            for (const entry of entries) {
+                if (entry.target !== this.host.el)
+                    continue;
+                if (!entry.isIntersecting)
+                    continue;
+                this.checkLazyValidation();
+                this.discardVisibilityObserver();
+            }
+        }, {
+            root: this.host.el.parentElement,
+            rootMargin: '0px',
+            threshold: 0.01,
+        });
+        this.visibilityObserver.observe(this.host.el);
+    }
+    checkLazyValidation() {
+        if (!this.config?.reValidateOnPropChanges && (this.elementQueued || this.elementValidated))
+            return;
+        this.enqueueValidation();
+    }
+    enqueueValidation() {
+        if (!AriaValidationController.globalValidationEnabled)
+            return;
+        this.elementQueued = true;
+        Effect.runPromise(AriaValidationController.axeQueue?.offer({
+            context: { include: this.host.el, exclude: this.knownValidationErrors },
+            onComplete: (error, results) => {
+                this.elementValidated = true;
+                if (error) {
+                    console.error('Error running ARIA validation:', error);
+                    return;
+                }
+                if (!results?.violations.length) {
+                    if (this.config?.verboseLogging) {
+                        console.log(`No ARIA validation violations found for ${this.host.el?.tagName || 'element'}.`);
+                    }
+                    return;
+                }
+                const label = `ARIA validation violations found for ${this.host.el?.tagName || 'element'}`;
+                if (this.config?.verboseLogging) {
+                    console.group(label);
+                }
+                else {
+                    console.groupCollapsed(label);
+                }
+                const targets = results.violations.flatMap(violation => {
+                    console.dir(violation, { showHidden: true, compact: false });
+                    return violation.nodes.map(node => node.target);
+                });
+                console.log('element:', this.host.el);
+                console.groupEnd();
+                this.knownValidationErrors.push(...targets);
+            },
+        }));
+    }
+    discardVisibilityObserver() {
+        if (!this.visibilityObserver)
+            return;
+        this.visibilityObserver.disconnect();
+        this.visibilityObserver = undefined;
+    }
+}

package/dist/collection/utils/validation/svg.js

@@ -0,0 +1,24 @@
+import { Brand, Data, Effect } from "effect";
+export const SVGString = Brand.refined(isValidSVG, () => Brand.error('SVG data is malformed'));
+export class BrandValidationError extends Data.TaggedError('BrandValidationError') {
+    constructor(error, type) {
+        super(new Error(`Brand validation failed for type ${type}.`, { cause: error }));
+    }
+}
+export const createValidSVGString = (svg) => Effect.try({
+    try: () => SVGString(svg),
+    catch: error => new BrandValidationError(error, 'SVGString'),
+});
+function isValidSVG(svg) {
+    if (typeof svg !== 'string') {
+        return false;
+    }
+    try {
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(svg, 'image/svg+xml');
+        return doc.documentElement.nodeName === 'svg';
+    }
+    catch {
+        return false;
+    }
+}

package/dist/components/index.d.ts

@@ -0,0 +1,53 @@
+/* LmvzComponents custom elements */
+export { LmvzAction as LmvzAction } from '../types/components/lmvz-action/lmvz-action';
+export { defineCustomElement as defineCustomElementLmvzAction } from './lmvz-action';
+export { LmvzButton as LmvzButton } from '../types/components/lmvz-button/lmvz-button';
+export { defineCustomElement as defineCustomElementLmvzButton } from './lmvz-button';
+export { LmvzCard as LmvzCard } from '../types/components/lmvz-card/lmvz-card';
+export { defineCustomElement as defineCustomElementLmvzCard } from './lmvz-card';
+export { LmvzChip as LmvzChip } from '../types/components/lmvz-chip/lmvz-chip';
+export { defineCustomElement as defineCustomElementLmvzChip } from './lmvz-chip';
+export { LmvzHeader as LmvzHeader } from '../types/components/lmvz-header/lmvz-header';
+export { defineCustomElement as defineCustomElementLmvzHeader } from './lmvz-header';
+export { LmvzIcon as LmvzIcon } from '../types/components/lmvz-icon/lmvz-icon';
+export { defineCustomElement as defineCustomElementLmvzIcon } from './lmvz-icon';
+export { LmvzInput as LmvzInput } from '../types/components/lmvz-input/lmvz-input';
+export { defineCustomElement as defineCustomElementLmvzInput } from './lmvz-input';
+export { LmvzMenuItem as LmvzMenuitem } from '../types/components/lmvz-menuitem/lmvz-menuitem';
+export { defineCustomElement as defineCustomElementLmvzMenuitem } from './lmvz-menuitem';
+
+/**
+ * Get the base path to where the assets can be found. Use "setAssetPath(path)"
+ * if the path needs to be customized.
+ */
+export declare const getAssetPath: (path: string) => string;
+
+/**
+ * Used to manually set the base path where assets can be found.
+ * If the script is used as "module", it's recommended to use "import.meta.url",
+ * such as "setAssetPath(import.meta.url)". Other options include
+ * "setAssetPath(document.currentScript.src)", or using a bundler's replace plugin to
+ * dynamically set the path at build time, such as "setAssetPath(process.env.ASSET_PATH)".
+ * But do note that this configuration depends on how your script is bundled, or lack of
+ * bundling, and where your assets can be loaded from. Additionally custom bundling
+ * will have to ensure the static assets are copied to its build directory.
+ */
+export declare const setAssetPath: (path: string) => void;
+
+/**
+ * Used to specify a nonce value that corresponds with an application's CSP.
+ * When set, the nonce will be added to all dynamically created script and style tags at runtime.
+ * Alternatively, the nonce value can be set on a meta tag in the DOM head
+ * (<meta name="csp-nonce" content="{ nonce value here }" />) which
+ * will result in the same behavior.
+ */
+export declare const setNonce: (nonce: string) => void
+
+export interface SetPlatformOptions {
+  raf?: (c: FrameRequestCallback) => number;
+  ael?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+  rel?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+}
+export declare const setPlatformOptions: (opts: SetPlatformOptions) => void;
+
+export * from '../types';