@lynx-js/web-elements 0.2.4

package/dist/XViewpagerNg/XViewpagerItemNg.js

@@ -0,0 +1,30 @@
+import { __esDecorate, __runInitializers } from "tslib";
+/*
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+*/
+import { Component } from '@lynx-js/web-elements-reactive';
+import { LynxExposure } from '../common/Exposure.js';
+let XViewpagerItemNg = (() => {
+    let _classDecorators = [Component('x-viewpager-item-ng', [
+            LynxExposure,
+        ])];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = HTMLElement;
+    var XViewpagerItemNg = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            XViewpagerItemNg = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return XViewpagerItemNg = _classThis;
+})();
+export { XViewpagerItemNg };
+//# sourceMappingURL=XViewpagerItemNg.js.map

package/dist/XViewpagerNg/XViewpagerNg.d.ts

@@ -0,0 +1,10 @@
+import { scrollContainerDom } from '../common/constants.js';
+export declare class XViewpagerNg extends HTMLElement {
+    static notToFilterFalseAttributes: Set<string>;
+    selectTab(params: {
+        index: number;
+        smooth?: boolean;
+    }): void;
+    connectedCallback(): void;
+    get [scrollContainerDom](): this;
+}

package/dist/XViewpagerNg/XViewpagerNg.js

@@ -0,0 +1,98 @@
+import { __esDecorate, __runInitializers } from "tslib";
+/*
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+*/
+import { boostedQueueMicrotask, Component, html, } from '@lynx-js/web-elements-reactive';
+import { LynxExposure } from '../common/Exposure.js';
+import { XViewpagerNgEvents } from './XViewpagerNgEvents.js';
+import { scrollContainerDom } from '../common/constants.js';
+let XViewpagerNg = (() => {
+    let _classDecorators = [Component('x-viewpager-ng', [LynxExposure, XViewpagerNgEvents], html `
+    <style>
+      #bounce-padding {
+        display: none;
+        flex: 0 0 0;
+        align-self: stretch;
+        scroll-snap-align: none;
+        flex-basis: 100%;
+      }
+      #content {
+        flex: 0 0 100%;
+        flex-direction: row;
+        align-self: stretch;
+        display: inherit;
+        justify-content: inherit;
+        align-items: inherit;
+        overflow: inherit;
+        scrollbar-width: none;
+        scroll-snap-type: inherit;
+      }
+      #content::-webkit-scrollbar {
+        display: none;
+      }
+    </style>
+    <div id="bounce-padding" part="bounce-padding"></div>
+    <div id="content" part="content">
+      <slot></slot>
+    </div>
+  `)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = HTMLElement;
+    var XViewpagerNg = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            XViewpagerNg = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static notToFilterFalseAttributes = new Set([
+            'allow-horizontal-gesture',
+            'enable-scroll',
+        ]);
+        selectTab(params) {
+            let { index, smooth } = params;
+            if (typeof smooth === 'undefined')
+                smooth = true;
+            const scrollContainer = this.shadowRoot.children.item(2);
+            const scrollLeft = scrollContainer.clientWidth * index;
+            scrollContainer.scrollTo({
+                left: scrollLeft,
+                behavior: smooth ? 'smooth' : 'instant',
+            });
+        }
+        connectedCallback() {
+            const initialSelectIndex = this.getAttribute('select-index')
+                || this.getAttribute('initial-select-index');
+            if (initialSelectIndex !== null) {
+                const selectIndex = Number(initialSelectIndex);
+                const scrollContainer = this.shadowRoot.children.item(2);
+                const scrollToInitialIndex = () => {
+                    if (scrollContainer.clientWidth === 0) {
+                        // In Safari, there is the potential race condition between the browser's layout and clientWidth calculate.
+                        // So, we have to use requestAnimationFrame to ensure that the code runs after the browser's layout.
+                        requestAnimationFrame(scrollToInitialIndex);
+                    }
+                    else {
+                        this.selectTab({ index: selectIndex, smooth: false });
+                    }
+                };
+                // The reason for using microtasks is that the width and height of the child element may not be rendered at this time, so it will not be able to scroll.
+                boostedQueueMicrotask(scrollToInitialIndex);
+            }
+        }
+        get [scrollContainerDom]() {
+            return this;
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return XViewpagerNg = _classThis;
+})();
+export { XViewpagerNg };
+//# sourceMappingURL=XViewpagerNg.js.map

package/dist/XViewpagerNg/XViewpagerNgEvents.d.ts

@@ -0,0 +1,9 @@
+import { type AttributeReactiveClass } from '@lynx-js/web-elements-reactive';
+import { XViewpagerNg } from './XViewpagerNg.js';
+export declare class XViewpagerNgEvents implements InstanceType<AttributeReactiveClass<typeof XViewpagerNg>> {
+    #private;
+    static observedAttributes: string[];
+    constructor(dom: XViewpagerNg);
+    connectedCallback(): void;
+    dispose(): void;
+}

package/dist/XViewpagerNg/XViewpagerNgEvents.js

@@ -0,0 +1,118 @@
+import { __esDecorate, __runInitializers, __setFunctionName } from "tslib";
+/*
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+*/
+import { genDomGetter, registerAttributeHandler, } from '@lynx-js/web-elements-reactive';
+import { commonComponentEventSetting } from '../common/commonEventInitConfiguration.js';
+import { useScrollEnd } from '../common/constants.js';
+let XViewpagerNgEvents = (() => {
+    let _instanceExtraInitializers = [];
+    let _private_enableScrollEventListener_decorators;
+    let _private_enableScrollEventListener_descriptor;
+    return class XViewpagerNgEvents {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _private_enableScrollEventListener_decorators = [registerAttributeHandler('x-enable-change-event', true), registerAttributeHandler('x-enable-offsetchange-event', true)];
+            __esDecorate(this, _private_enableScrollEventListener_descriptor = { value: __setFunctionName(function () {
+                    this.#enableChange =
+                        this.#dom.getAttribute('x-enable-change-event') !== null;
+                    const enableOffsetChange = this.#dom.getAttribute('x-enable-offsetchange-event') !== null;
+                    const scrollContainer = this.#getScrollContainer();
+                    if (enableOffsetChange !== null || this.#enableChange) {
+                        scrollContainer.addEventListener('scroll', this.#scrollHandler, {
+                            passive: true,
+                        });
+                    }
+                    else {
+                        scrollContainer.removeEventListener('scroll', this.#scrollHandler);
+                    }
+                    if (useScrollEnd && this.#enableChange) {
+                        scrollContainer.addEventListener('scrollend', this.#scrollEndHandler, {
+                            passive: true,
+                        });
+                    }
+                    else {
+                        scrollContainer.removeEventListener('scrollend', this.#scrollEndHandler);
+                    }
+                }, "#enableScrollEventListener") }, _private_enableScrollEventListener_decorators, { kind: "method", name: "#enableScrollEventListener", static: false, private: true, access: { has: obj => #enableScrollEventListener in obj, get: obj => obj.#enableScrollEventListener }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static observedAttributes = [
+            'x-enable-change-event',
+            'x-enable-offsetchange-event',
+        ];
+        #dom = __runInitializers(this, _instanceExtraInitializers);
+        #isDragging = false;
+        #connected = false;
+        #currentIndex = 0;
+        #enableChange = false;
+        #debounceScrollForMockingScrollEnd;
+        constructor(dom) {
+            this.#dom = dom;
+        }
+        #getScrollContainer = genDomGetter(() => this.#dom.shadowRoot, '#content');
+        #scrollHandler = () => {
+            if (!this.#connected)
+                return;
+            const scrollContainer = this.#getScrollContainer();
+            const oneItemWidth = this.#dom.clientWidth;
+            const scrollLeft = scrollContainer.scrollLeft;
+            const innerOffset = scrollLeft / oneItemWidth;
+            if (this.#enableChange && !useScrollEnd) {
+                // debounce
+                clearTimeout(this.#debounceScrollForMockingScrollEnd);
+                this.#debounceScrollForMockingScrollEnd = setTimeout(() => {
+                    this.#scrollEndHandler();
+                }, 100);
+            }
+            this.#dom.dispatchEvent(new CustomEvent('offsetchange', {
+                ...commonComponentEventSetting,
+                detail: { offset: innerOffset },
+            }));
+        };
+        #scrollEndHandler = () => {
+            if (this.#connected) {
+                const scrollContainer = this.#getScrollContainer();
+                const oneItemWidth = this.#dom.clientWidth;
+                const scrollLeft = scrollContainer.scrollLeft;
+                const currentIndex = Math.floor(scrollLeft / oneItemWidth);
+                if (currentIndex !== this.#currentIndex) {
+                    this.#dom.dispatchEvent(new CustomEvent('change', {
+                        ...commonComponentEventSetting,
+                        detail: { index: currentIndex, isDragged: this.#isDragging },
+                    }));
+                    this.#currentIndex = currentIndex;
+                }
+            }
+        };
+        #touchStartHandler = () => {
+            this.#isDragging = true;
+        };
+        #touchEndHandler = () => {
+            this.#isDragging = false;
+        };
+        get #enableScrollEventListener() { return _private_enableScrollEventListener_descriptor.value; }
+        connectedCallback() {
+            this.#connected = true;
+            const scrollContainer = this.#getScrollContainer();
+            this.#dom.addEventListener('touchstart', this.#touchStartHandler, {
+                passive: true,
+            });
+            scrollContainer.addEventListener('touchend', this.#touchEndHandler, {
+                passive: true,
+            });
+            scrollContainer.addEventListener('touchcancel', this.#touchEndHandler, {
+                passive: true,
+            });
+        }
+        dispose() {
+            const scrollContainer = this.#getScrollContainer();
+            scrollContainer.removeEventListener('scroll', this.#scrollHandler);
+            scrollContainer.removeEventListener('scrollend', this.#scrollEndHandler);
+        }
+    };
+})();
+export { XViewpagerNgEvents };
+//# sourceMappingURL=XViewpagerNgEvents.js.map

package/dist/XViewpagerNg/index.d.ts

@@ -0,0 +1,2 @@
+export { XViewpagerNg } from './XViewpagerNg.js';
+export { XViewpagerItemNg } from './XViewpagerItemNg.js';

package/dist/XViewpagerNg/index.js

@@ -0,0 +1,3 @@
+export { XViewpagerNg } from './XViewpagerNg.js';
+export { XViewpagerItemNg } from './XViewpagerItemNg.js';
+//# sourceMappingURL=index.js.map

package/dist/all.d.ts

@@ -0,0 +1,16 @@
+import './LynxWrapper/index.js';
+import './ScrollView/index.js';
+import './XAudioTT/index.js';
+import './XCanvas/XCanvas.js';
+import './XFoldViewNg/index.js';
+import './XImage/index.js';
+import './XInput/index.js';
+import './XOverlayNg/index.js';
+import './XRefreshView/index.js';
+import './XSvg/index.js';
+import './XSwiper/index.js';
+import './XText/index.js';
+import './XTextarea/index.js';
+import './XView/index.js';
+import './XViewpagerNg/index.js';
+import './XList/index.js';

package/dist/all.js

@@ -0,0 +1,17 @@
+import './LynxWrapper/index.js';
+import './ScrollView/index.js';
+import './XAudioTT/index.js';
+import './XCanvas/XCanvas.js';
+import './XFoldViewNg/index.js';
+import './XImage/index.js';
+import './XInput/index.js';
+import './XOverlayNg/index.js';
+import './XRefreshView/index.js';
+import './XSvg/index.js';
+import './XSwiper/index.js';
+import './XText/index.js';
+import './XTextarea/index.js';
+import './XView/index.js';
+import './XViewpagerNg/index.js';
+import './XList/index.js';
+//# sourceMappingURL=all.js.map

package/dist/common/Exposure.d.ts

@@ -0,0 +1,28 @@
+export interface ExposureParameters {
+    exposureID: string | null;
+    exposureArea: string | null;
+    exposureScene: string | null;
+    exposureScreenMarginTop: string | null;
+    exposureScreenMarginRight: string | null;
+    exposureScreenMarginBottom: string | null;
+    exposureScreenMarginLeft: string | null;
+    exposureUIMarginTop: string | null;
+    exposureUIMarginRight: string | null;
+    exposureUIMarginBottom: string | null;
+    exposureUIMarginLeft: string | null;
+}
+export interface ExposureEvent {
+    'exposure-id': string;
+    'exposure-scene': string;
+    exposureID: string;
+    exposureScene: string;
+}
+export declare class LynxExposure {
+    #private;
+    static readonly observedAttributes: string[];
+    constructor(currentElement: HTMLElement);
+    onExposureParamsChanged: () => void;
+    onExposureIdChanged(_: string | null, oldValue: string | null): void;
+    attributeChangedHandler: this;
+    disableExposure(): void;
+}

package/dist/common/Exposure.js

@@ -0,0 +1,193 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { convertLengthToPx } from './convertLengthToPx.js';
+import { commonComponentEventSetting } from './commonEventInitConfiguration.js';
+import { scrollContainerDom } from './constants.js';
+export class LynxExposure {
+    static observedAttributes = [
+        'x-enable-uiappear-event',
+        'x-enable-uidisappear-event',
+        'exposure-id',
+        'exposure-area',
+        'exposure-screen-margin-top',
+        'exposure-screen-margin-right',
+        'exposure-screen-margin-bottom',
+        'exposure-screen-margin-left',
+        'exposure-ui-margin-top',
+        'exposure-ui-margin-right',
+        'exposure-ui-margin-bottom',
+        'exposure-ui-margin-left',
+    ];
+    #currentElement;
+    /**
+     * Stores a promise. We will handler the exposure attribute change after all related life-cycle events has been fired by browser.
+     */
+    #afterAttributeChanged;
+    /**
+     * If this dom is already exposured
+     */
+    #exposureTriggerd = false;
+    /**
+     * keeps the observer of current dom
+     */
+    #exposureObserver;
+    get #exposureEnabled() {
+        return (this.#currentElement.getAttribute('x-enable-uiappear-event') !== null
+            || this.#currentElement.getAttribute('x-enable-uidisappear-event')
+                !== null
+            || this.#currentElement.getAttribute('exposure-id') !== null);
+    }
+    constructor(currentElement) {
+        this.#currentElement = currentElement;
+    }
+    onExposureParamsChanged = () => {
+        if (!this.#afterAttributeChanged) {
+            this.#afterAttributeChanged = Promise.resolve().then(() => {
+                this.#updateExposure();
+                this.#afterAttributeChanged = undefined;
+            });
+        }
+    };
+    onExposureIdChanged(_, oldValue) {
+        if (oldValue) {
+            if (this.#exposureEnabled) {
+                this.#sendOneExposureEvent({ isIntersecting: false }, oldValue);
+            }
+        }
+        this.onExposureParamsChanged();
+    }
+    attributeChangedHandler = new Proxy(this, {
+        get(target, attribute) {
+            if (LynxExposure.observedAttributes.includes(attribute)) {
+                if (attribute === 'exposure-id') {
+                    return { handler: target.onExposureIdChanged, noDomMeasure: true };
+                }
+                else {
+                    return {
+                        handler: target.onExposureParamsChanged,
+                        noDomMeasure: true,
+                    };
+                }
+            }
+            return;
+        },
+    });
+    #updateExposure() {
+        const newParams = {
+            exposureID: this.#currentElement.getAttribute('exposure-id'),
+            exposureArea: this.#currentElement.getAttribute('exposure-area'),
+            exposureScene: this.#currentElement.getAttribute('exposure-scene'),
+            exposureScreenMarginTop: this.#currentElement.getAttribute('exposure-screen-margin-top'),
+            exposureScreenMarginRight: this.#currentElement.getAttribute('exposure-screen-margin-right'),
+            exposureScreenMarginBottom: this.#currentElement.getAttribute('exposure-screen-margin-bottom'),
+            exposureScreenMarginLeft: this.#currentElement.getAttribute('exposure-screen-margin-left'),
+            exposureUIMarginTop: this.#currentElement.getAttribute('exposure-ui-margin-top'),
+            exposureUIMarginRight: this.#currentElement.getAttribute('exposure-ui-margin-right'),
+            exposureUIMarginBottom: this.#currentElement.getAttribute('exposure-ui-margin-bottom'),
+            exposureUIMarginLeft: this.#currentElement.getAttribute('exposure-ui-margin-left'),
+        };
+        if (this.#exposureEnabled) {
+            if (IntersectionObserver) {
+                const uiMargin = {
+                    top: convertLengthToPx(this.#currentElement, newParams.exposureUIMarginTop),
+                    right: convertLengthToPx(this.#currentElement, newParams.exposureUIMarginRight, true),
+                    bottom: convertLengthToPx(this.#currentElement, newParams.exposureUIMarginBottom),
+                    left: convertLengthToPx(this.#currentElement, newParams.exposureUIMarginLeft, true),
+                };
+                const screenMargin = {
+                    top: convertLengthToPx(this.#currentElement, newParams.exposureScreenMarginTop),
+                    right: convertLengthToPx(this.#currentElement, newParams.exposureScreenMarginRight, true),
+                    bottom: convertLengthToPx(this.#currentElement, newParams.exposureScreenMarginBottom),
+                    left: convertLengthToPx(this.#currentElement, newParams.exposureScreenMarginLeft, true),
+                };
+                /**
+                 * TODO: @haoyang.wang support the switch `enableExposureUIMargin`
+                 */
+                const calcedRootMargin = {
+                    top: (uiMargin.bottom ? -1 : 1)
+                        * (screenMargin.top - uiMargin.bottom),
+                    right: (uiMargin.left ? -1 : 1)
+                        * (screenMargin.right - uiMargin.left),
+                    bottom: (uiMargin.top ? -1 : 1)
+                        * (screenMargin.bottom - uiMargin.top),
+                    left: (uiMargin.right ? -1 : 1)
+                        * (screenMargin.left - uiMargin.right),
+                };
+                const exposureArea = this.#currentElement.getAttribute('exposure-area');
+                const rootMargin = `${calcedRootMargin.top}px ${calcedRootMargin.right}px ${calcedRootMargin.bottom}px ${calcedRootMargin.left}px`;
+                const threshold = exposureArea ? parseFloat(exposureArea) / 100 : 0;
+                if (this.#exposureObserver) {
+                    this.#exposureObserver.disconnect();
+                }
+                /**
+                 * Get the closest scrollable ancestor
+                 */
+                let root = this.#currentElement.parentElement;
+                while (root) {
+                    // @ts-expect-error
+                    if (root[scrollContainerDom]) {
+                        // @ts-expect-error
+                        root = root[scrollContainerDom];
+                        break;
+                    }
+                    else {
+                        root = root.parentElement;
+                    }
+                }
+                this.#exposureTriggerd = false;
+                this.#exposureObserver = new IntersectionObserver(([entry]) => {
+                    if (entry) {
+                        if (entry.isIntersecting) {
+                            this.#exposureTriggerd = true;
+                        }
+                        this.#sendOneExposureEvent(entry);
+                    }
+                }, {
+                    rootMargin,
+                    threshold,
+                    root,
+                });
+                this.#exposureObserver.observe(this.#currentElement);
+            }
+        }
+        else {
+            this.disableExposure();
+        }
+    }
+    #sendOneExposureEvent(entry, overrideExposureId) {
+        if (!this.#exposureTriggerd) {
+            return;
+        }
+        const exposureID = overrideExposureId
+            ?? this.#currentElement.getAttribute('exposure-id') ?? '';
+        const exposureScene = this.#currentElement.getAttribute('exposure-scene')
+            ?? '';
+        const detail = {
+            'exposure-id': exposureID,
+            'exposure-scene': exposureScene,
+            exposureID,
+            exposureScene,
+        };
+        const appearEvent = new CustomEvent(entry.isIntersecting ? 'uiappear' : 'uidisappear', {
+            ...commonComponentEventSetting,
+            detail,
+        });
+        const exposureEvent = new CustomEvent(entry.isIntersecting ? 'exposure' : 'disexposure', {
+            bubbles: true,
+            composed: false,
+            cancelable: false,
+            detail,
+        });
+        Object.assign(appearEvent, detail);
+        this.#currentElement.dispatchEvent(appearEvent);
+        this.#currentElement.dispatchEvent(exposureEvent);
+    }
+    disableExposure() {
+        if (this.#exposureObserver) {
+            this.#exposureObserver.disconnect();
+            this.#exposureObserver = undefined;
+        }
+    }
+}
+//# sourceMappingURL=Exposure.js.map

package/dist/common/bindToIntersectionObserver.d.ts

@@ -0,0 +1 @@
+export declare function bindToIntersectionObserver(rootGetter: () => HTMLElement, targetGetter: () => HTMLElement, callback: IntersectionObserverCallback): (newVal: string | null) => void;

package/dist/common/bindToIntersectionObserver.js

@@ -0,0 +1,23 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+export function bindToIntersectionObserver(rootGetter, targetGetter, callback) {
+    let observer;
+    return (newVal) => {
+        if (newVal !== null) {
+            if (!observer) {
+                observer = new IntersectionObserver(callback, {
+                    root: rootGetter(),
+                });
+                observer.observe(targetGetter());
+            }
+        }
+        else {
+            if (observer) {
+                observer.disconnect();
+                observer = undefined;
+            }
+        }
+    };
+}
+//# sourceMappingURL=bindToIntersectionObserver.js.map

package/dist/common/commonEventInitConfiguration.d.ts

@@ -0,0 +1,5 @@
+export declare const commonComponentEventSetting: {
+    readonly bubbles: false;
+    readonly composed: false;
+    readonly cancelable: true;
+};

package/dist/common/commonEventInitConfiguration.js

@@ -0,0 +1,9 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+export const commonComponentEventSetting = {
+    bubbles: false,
+    composed: false,
+    cancelable: true,
+};
+//# sourceMappingURL=commonEventInitConfiguration.js.map

package/dist/common/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const useScrollEnd: boolean;
+export declare const isChromium: boolean;
+export declare const isWebkit: boolean;
+export declare const scrollContainerDom: unique symbol;

package/dist/common/constants.js

@@ -0,0 +1,14 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+// safari cannot use scrollend event
+export const useScrollEnd = 'onscrollend' in document;
+const UA = window.navigator.userAgent;
+export const isChromium = UA.includes('Chrome');
+export const isWebkit = /\b(iPad|iPhone|iPod|OS X)\b/.test(UA)
+    && !/Edge/.test(UA)
+    && /WebKit/.test(UA)
+    // @ts-expect-error
+    && !window.MSStream;
+export const scrollContainerDom = Symbol();
+//# sourceMappingURL=constants.js.map

package/dist/common/convertLengthToPx.d.ts

@@ -0,0 +1 @@
+export declare function convertLengthToPx(targetElement: HTMLElement, str: string | null, isWidth?: boolean): number;

package/dist/common/convertLengthToPx.js

@@ -0,0 +1,25 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+export function convertLengthToPx(targetElement, str, isWidth) {
+    if (str) {
+        str = str.trim();
+        if (str.endsWith('px')) {
+            return Number(str.substring(0, str.length - 2));
+        }
+        else if (str.endsWith('%')) {
+            const pct = Number(str.substring(0, str.length - 1));
+            const { width, height } = targetElement.getBoundingClientRect();
+            const base = isWidth ? width : height;
+            return (base * pct) / 100;
+        }
+        else {
+            /**
+             * TODO (haoyang.wang): support rpx
+             */
+            return 0;
+        }
+    }
+    return 0;
+}
+//# sourceMappingURL=convertLengthToPx.js.map

package/dist/common/renameEvent.d.ts

@@ -0,0 +1 @@
+export declare const renameEvent: Record<string, string>;

package/dist/common/renameEvent.js

@@ -0,0 +1,6 @@
+export const renameEvent = {
+    'submit': 'confirm',
+    'blur': 'lynxblur',
+    'focus': 'lynxfocus',
+};
+//# sourceMappingURL=renameEvent.js.map

package/dist/common/throttle.d.ts

@@ -0,0 +1,4 @@
+export declare const throttle: (func: () => unknown, wait: number, options?: {
+    leading: boolean;
+    trailing: boolean;
+}) => (this: unknown) => any;