@lynx-js/web-elements 0.2.4

package/dist/XAudioTT/XAudioEvents.d.ts

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

package/dist/XAudioTT/XAudioEvents.js

@@ -0,0 +1,116 @@
+/*
+// 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, } from '@lynx-js/web-elements-reactive';
+import { audioLoadingStateMap, audioPlaybackStateMap, XAudioErrorCode, xAudioSrc, } from './utils.js';
+import { commonComponentEventSetting } from '../common/commonEventInitConfiguration.js';
+export class XAudioEvents {
+    static observedAttributes = [];
+    #dom;
+    #intervalPlay;
+    #getAudioElement = genDomGetter(() => this.#dom.shadowRoot, '#audio');
+    #playEvent = (event) => {
+        const attributeInterval = Number(this.#dom.getAttribute('interval'));
+        const delay = Number.isNaN(attributeInterval) ? 0 : attributeInterval;
+        this.#intervalPlay = setInterval(() => {
+            this.#dom.dispatchEvent(new CustomEvent('timeupdate', {
+                ...commonComponentEventSetting,
+                detail: {
+                    currentTime: this.#getAudioElement().currentTime,
+                    currentSrcID: this.#dom[xAudioSrc]?.id,
+                },
+            }));
+        }, delay);
+        const playbackState = audioPlaybackStateMap[event.type];
+        this.#dom.dispatchEvent(new CustomEvent('playbackstatechanged', {
+            ...commonComponentEventSetting,
+            detail: {
+                code: playbackState?.code,
+                type: playbackState?.type,
+                currentSrcID: this.#dom[xAudioSrc]?.id,
+            },
+        }));
+    };
+    #pauseEvent = (event) => {
+        clearInterval(this.#intervalPlay);
+        const playbackState = audioPlaybackStateMap[event.type];
+        this.#dom.dispatchEvent(new CustomEvent('playbackstatechanged', {
+            ...commonComponentEventSetting,
+            detail: {
+                code: playbackState?.code,
+                type: playbackState?.type,
+                currentSrcID: this.#dom[xAudioSrc]?.id,
+            },
+        }));
+    };
+    #loadingEvent = (event) => {
+        const loadingState = audioLoadingStateMap[event.type];
+        this.#dom.dispatchEvent(new CustomEvent('loadingstatechanged', {
+            ...commonComponentEventSetting,
+            detail: {
+                code: loadingState?.code,
+                type: loadingState?.type,
+                currentSrcID: this.#dom[xAudioSrc]?.id,
+            },
+        }));
+    };
+    #errorEvent = (event) => {
+        this.#loadingEvent(event);
+        const mediaCode = event.target?.error?.code;
+        let code = mediaCode === MediaError.MEDIA_ERR_DECODE
+            ? XAudioErrorCode.PlayerLoadingError
+            : XAudioErrorCode.PlayerPlaybackError;
+        if (mediaCode === MediaError.MEDIA_ERR_DECODE) {
+            code = XAudioErrorCode.PlayerLoadingError;
+        }
+        this.#dom.dispatchEvent(new CustomEvent('error', {
+            ...commonComponentEventSetting,
+            detail: {
+                code,
+                msg: '',
+                from: 'player',
+                currentSrcID: this.#dom[xAudioSrc]?.id,
+            },
+        }));
+    };
+    #endedEvent = () => {
+        const loop = this.#dom.getAttribute('loop') === null ? false : true;
+        this.#dom.dispatchEvent(new CustomEvent('finished', {
+            ...commonComponentEventSetting,
+            detail: {
+                loop,
+                currentSrcID: this.#dom[xAudioSrc]?.id,
+            },
+        }));
+    };
+    constructor(dom) {
+        this.#dom = dom;
+    }
+    connectedCallback() {
+        const audioElement = this.#getAudioElement();
+        audioElement.addEventListener('play', this.#playEvent, {
+            passive: true,
+        });
+        audioElement.addEventListener('pause', this.#pauseEvent, {
+            passive: true,
+        });
+        audioElement.addEventListener('ended', this.#endedEvent, {
+            passive: true,
+        });
+        audioElement.addEventListener('loadstart', this.#loadingEvent, {
+            passive: true,
+        });
+        audioElement.addEventListener('canplay', this.#loadingEvent, {
+            passive: true,
+        });
+        audioElement.addEventListener('stalled', this.#loadingEvent, {
+            passive: true,
+        });
+        audioElement.addEventListener('error', this.#errorEvent, {
+            passive: true,
+        });
+    }
+}
+//# sourceMappingURL=XAudioEvents.js.map

package/dist/XAudioTT/XAudioTT.d.ts

@@ -0,0 +1,46 @@
+import { xAudioBlob, xAudioSrc } from './utils.js';
+export declare class XAudioTT extends HTMLElement {
+    #private;
+    [xAudioSrc]?: {
+        id: string;
+        play_url: string;
+    };
+    [xAudioBlob]?: Promise<void>;
+    play(): {
+        currentSrcID: string | undefined;
+        loadingSrcID: string;
+    };
+    stop(): {
+        currentSrcID: string | undefined;
+    };
+    pause(): {
+        currentSrcID: string | undefined;
+    };
+    resume(): {
+        currentSrcID: string | undefined;
+        loadingSrcID: string;
+    };
+    seek(params: {
+        currentTime: number;
+    }): {
+        currentSrcID: string | undefined;
+    };
+    mute(params: {
+        mute: boolean;
+    }): {
+        currentSrcID: string | undefined;
+    };
+    playerInfo(): {
+        currentSrcID: string | undefined;
+        duration: number;
+        playbackState: number;
+        currentTime: number;
+        cacheTime: number;
+    };
+    prepare(): void;
+    setVolume(params: {
+        volume: number;
+    }): {
+        code: number;
+    };
+}

package/dist/XAudioTT/XAudioTT.js

@@ -0,0 +1,183 @@
+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, html, genDomGetter, bindToAttribute, } from '@lynx-js/web-elements-reactive';
+import { XAudioAttribute } from './XAudioAttribute.js';
+import { XAudioEvents } from './XAudioEvents.js';
+import { LynxExposure } from '../common/Exposure.js';
+import { commonComponentEventSetting } from '../common/commonEventInitConfiguration.js';
+import { XAudioErrorCode, audioPlaybackStateMap, getAudioState, xAudioBlob, xAudioSrc, } from './utils.js';
+let XAudioTT = (() => {
+    let _classDecorators = [Component('x-audio-tt', [LynxExposure, XAudioAttribute, XAudioEvents], html `<audio id="audio"></audio>`)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = HTMLElement;
+    var XAudioTT = 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);
+            XAudioTT = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        #getAudio = genDomGetter(() => this.shadowRoot, '#audio');
+        #getAudioElement = genDomGetter(() => this.shadowRoot, '#audio');
+        #setAudioSrc = bindToAttribute(this.#getAudioElement, 'src');
+        [xAudioSrc];
+        [xAudioBlob];
+        #fetchAudio = () => {
+            const parsedSrc = this[xAudioSrc];
+            if (!parsedSrc || !parsedSrc.id || !parsedSrc.play_url) {
+                return;
+            }
+            let parsedHeaders;
+            try {
+                parsedHeaders = JSON.parse(this.getAttribute('headers') || '{}')
+                    || {};
+            }
+            catch (error) {
+                console.error(`JSON.parse headers error: ${error}`);
+                parsedHeaders = {};
+            }
+            this[xAudioBlob] = new Promise(async (resolve, reject) => {
+                this.dispatchEvent(new CustomEvent('srcloadingstatechanged', {
+                    ...commonComponentEventSetting,
+                    detail: {
+                        code: 0,
+                        type: 'loading',
+                        currentSrcID: parsedSrc.id,
+                    },
+                }));
+                const response = await fetch(parsedSrc.play_url, {
+                    headers: parsedHeaders,
+                });
+                if (!response.ok) {
+                    this.dispatchEvent(new CustomEvent('error', {
+                        ...commonComponentEventSetting,
+                        detail: {
+                            code: XAudioErrorCode.DownloadError,
+                            msg: '',
+                            from: 'res loader',
+                            currentSrcID: parsedSrc.id,
+                        },
+                    }));
+                    reject();
+                }
+                this.dispatchEvent(new CustomEvent('srcloadingstatechanged', {
+                    ...commonComponentEventSetting,
+                    detail: {
+                        code: 1,
+                        type: 'success',
+                        currentSrcID: parsedSrc.id,
+                    },
+                }));
+                const blob = await response.blob();
+                const blobUrl = URL.createObjectURL(blob);
+                this.#setAudioSrc(blobUrl);
+                resolve();
+            });
+        };
+        play() {
+            // If prepare method is not called, needs to fetch first
+            if (!this[xAudioBlob]) {
+                this.#fetchAudio();
+            }
+            this[xAudioBlob]?.then(() => {
+                const audio = this.#getAudio();
+                audio.currentTime = 0;
+                audio.play();
+            });
+            return {
+                currentSrcID: this[xAudioSrc]?.id,
+                loadingSrcID: '',
+            };
+        }
+        stop() {
+            const audio = this.#getAudio();
+            const playbackState = audioPlaybackStateMap['stop'];
+            this.dispatchEvent(new CustomEvent('playbackstatechanged', {
+                ...commonComponentEventSetting,
+                detail: {
+                    code: playbackState?.code,
+                    type: playbackState?.type,
+                    currentSrcID: this[xAudioSrc]?.id,
+                },
+            }));
+            audio.currentTime = 0;
+            audio.pause();
+            return {
+                currentSrcID: this[xAudioSrc]?.id,
+            };
+        }
+        pause() {
+            const audio = this.#getAudio();
+            audio.pause();
+            return {
+                currentSrcID: this[xAudioSrc]?.id,
+            };
+        }
+        resume() {
+            const audio = this.#getAudio();
+            audio.play();
+            return {
+                currentSrcID: this[xAudioSrc]?.id,
+                loadingSrcID: '',
+            };
+        }
+        seek(params) {
+            const audio = this.#getAudio();
+            audio.currentTime = (params.currentTime || 0) / 1000;
+            this.dispatchEvent(new CustomEvent('seek', {
+                ...commonComponentEventSetting,
+                detail: {
+                    seekresult: 1,
+                    currentSrcID: this[xAudioSrc]?.id,
+                },
+            }));
+            return {
+                currentSrcID: this[xAudioSrc]?.id,
+            };
+        }
+        mute(params) {
+            const audio = this.#getAudio();
+            audio.muted = params.mute;
+            return {
+                currentSrcID: this[xAudioSrc]?.id,
+            };
+        }
+        playerInfo() {
+            const audioElement = this.#getAudio();
+            const buffered = audioElement.buffered;
+            const cacheTime = buffered.end(buffered.length - 1);
+            return {
+                currentSrcID: this[xAudioSrc]?.id,
+                duration: audioElement.duration * 1000,
+                playbackState: getAudioState(audioElement),
+                // playBitrate can not support now
+                currentTime: audioElement.currentTime,
+                cacheTime,
+            };
+        }
+        prepare() {
+            // if has fetched, no need to fetch again
+            if (!this[xAudioBlob]) {
+                this.#fetchAudio();
+            }
+        }
+        setVolume(params) {
+            const audio = this.#getAudio();
+            audio.volume = params.volume;
+            return {
+                code: 1,
+            };
+        }
+    };
+    return XAudioTT = _classThis;
+})();
+export { XAudioTT };
+//# sourceMappingURL=XAudioTT.js.map

package/dist/XAudioTT/index.d.ts

@@ -0,0 +1 @@
+export { XAudioTT } from './XAudioTT.js';

package/dist/XAudioTT/index.js

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

package/dist/XAudioTT/utils.d.ts

@@ -0,0 +1,19 @@
+export declare const xAudioSrc: unique symbol;
+export declare const xAudioBlob: unique symbol;
+export declare const audioLoadingStateMap: Record<string, {
+    code: number;
+    type: string;
+}>;
+export declare const audioPlaybackStateMap: Record<string, {
+    code: number;
+    type: string;
+}>;
+export declare const getAudioState: (audioElement: HTMLAudioElement) => 0 | 2 | 1 | -1 | 3;
+export declare const enum XAudioErrorCode {
+    SrcError = -1,
+    SrcJsonError = -2,
+    DownloadError = -3,
+    PlayerFinishedError = -4,
+    PlayerLoadingError = -5,
+    PlayerPlaybackError = -6
+}

package/dist/XAudioTT/utils.js

@@ -0,0 +1,66 @@
+/*
+// 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 xAudioSrc = Symbol('__src');
+export const xAudioBlob = Symbol('__src');
+export const audioLoadingStateMap = {
+    loadstart: {
+        code: 0,
+        type: 'init',
+    },
+    canplay: {
+        code: 1,
+        type: 'playable',
+    },
+    // Code 2 refers to the audio loading jam, which is a resource decoding problem
+    // cannot be implemented at present, use stalled replaced
+    stalled: {
+        code: 2,
+        type: 'stalled',
+    },
+    error: {
+        code: 3,
+        type: 'error',
+    },
+};
+export const audioPlaybackStateMap = {
+    stop: {
+        code: 0,
+        type: 'stopped',
+    },
+    play: {
+        code: 1,
+        type: 'playing',
+    },
+    pause: {
+        code: 2,
+        type: 'paused',
+    },
+};
+export const getAudioState = (audioElement) => {
+    if (!audioElement) {
+        return -1;
+    }
+    if (audioElement.paused) {
+        if (audioElement.ended) {
+            return 0;
+        }
+        return 2;
+    }
+    if (audioElement.currentTime > 0) {
+        return 1;
+    }
+    return 3;
+};
+export var XAudioErrorCode;
+(function (XAudioErrorCode) {
+    XAudioErrorCode[XAudioErrorCode["SrcError"] = -1] = "SrcError";
+    XAudioErrorCode[XAudioErrorCode["SrcJsonError"] = -2] = "SrcJsonError";
+    XAudioErrorCode[XAudioErrorCode["DownloadError"] = -3] = "DownloadError";
+    XAudioErrorCode[XAudioErrorCode["PlayerFinishedError"] = -4] = "PlayerFinishedError";
+    XAudioErrorCode[XAudioErrorCode["PlayerLoadingError"] = -5] = "PlayerLoadingError";
+    XAudioErrorCode[XAudioErrorCode["PlayerPlaybackError"] = -6] = "PlayerPlaybackError";
+})(XAudioErrorCode || (XAudioErrorCode = {}));
+//# sourceMappingURL=utils.js.map

package/dist/XCanvas/CanvasAttributes.d.ts

@@ -0,0 +1,12 @@
+import { AttributeReactiveClass } from '@lynx-js/web-elements-reactive';
+import { XCanvas } from './XCanvas.js';
+export declare class CanvasAttributes implements InstanceType<AttributeReactiveClass<typeof XCanvas>> {
+    #private;
+    static observedAttributes: string[];
+    constructor(dom: XCanvas);
+    handleName: (this: void, newVal: string | null) => void;
+    handleHeight: (this: void, newVal: string | null) => void;
+    handleWidth: (this: void, newVal: string | null) => void;
+    connectedCallback(): void;
+    dispose(): void;
+}

package/dist/XCanvas/CanvasAttributes.js

@@ -0,0 +1,78 @@
+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 { bindToAttribute, genDomGetter, registerAttributeHandler, } from '@lynx-js/web-elements-reactive';
+import { commonComponentEventSetting } from '../common/commonEventInitConfiguration.js';
+let CanvasAttributes = (() => {
+    let _handleName_decorators;
+    let _handleName_initializers = [];
+    let _handleName_extraInitializers = [];
+    let _handleHeight_decorators;
+    let _handleHeight_initializers = [];
+    let _handleHeight_extraInitializers = [];
+    let _handleWidth_decorators;
+    let _handleWidth_initializers = [];
+    let _handleWidth_extraInitializers = [];
+    return class CanvasAttributes {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _handleName_decorators = [registerAttributeHandler('name', true)];
+            _handleHeight_decorators = [registerAttributeHandler('height', true)];
+            _handleWidth_decorators = [registerAttributeHandler('height', true)];
+            __esDecorate(null, null, _handleName_decorators, { kind: "field", name: "handleName", static: false, private: false, access: { has: obj => "handleName" in obj, get: obj => obj.handleName, set: (obj, value) => { obj.handleName = value; } }, metadata: _metadata }, _handleName_initializers, _handleName_extraInitializers);
+            __esDecorate(null, null, _handleHeight_decorators, { kind: "field", name: "handleHeight", static: false, private: false, access: { has: obj => "handleHeight" in obj, get: obj => obj.handleHeight, set: (obj, value) => { obj.handleHeight = value; } }, metadata: _metadata }, _handleHeight_initializers, _handleHeight_extraInitializers);
+            __esDecorate(null, null, _handleWidth_decorators, { kind: "field", name: "handleWidth", static: false, private: false, access: { has: obj => "handleWidth" in obj, get: obj => obj.handleWidth, set: (obj, value) => { obj.handleWidth = value; } }, metadata: _metadata }, _handleWidth_initializers, _handleWidth_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static observedAttributes = ['name', 'height', 'width'];
+        #dom;
+        #resizeObserver;
+        #getCanvas = genDomGetter(() => this.#dom.shadowRoot, '#canvas');
+        constructor(dom) {
+            this.#dom = dom;
+        }
+        handleName = __runInitializers(this, _handleName_initializers, bindToAttribute(this.#getCanvas, 'name'));
+        handleHeight = (__runInitializers(this, _handleName_extraInitializers), __runInitializers(this, _handleHeight_initializers, bindToAttribute(this.#getCanvas, 'height')));
+        handleWidth = (__runInitializers(this, _handleHeight_extraInitializers), __runInitializers(this, _handleWidth_initializers, bindToAttribute(this.#getCanvas, 'width')));
+        #resizeHandler = (__runInitializers(this, _handleWidth_extraInitializers), (entries) => {
+            const { contentRect } = entries[0];
+            const canvas = this.#dom.shadowRoot.firstElementChild;
+            if (canvas) {
+                let { height, width } = contentRect;
+                height = height * window.devicePixelRatio;
+                width = width * window.devicePixelRatio;
+                const resizeEvent = new CustomEvent('resize', {
+                    ...commonComponentEventSetting,
+                    detail: {
+                        height,
+                        width,
+                    },
+                });
+                resizeEvent.height = height;
+                resizeEvent.width = width;
+                canvas.dispatchEvent(resizeEvent);
+            }
+        });
+        #startResizeObserver() {
+            if (!this.#resizeObserver) {
+                this.#resizeObserver = new ResizeObserver(this.#resizeHandler);
+                this.#resizeObserver.observe(this.#dom);
+            }
+        }
+        #stopResizeObserver() {
+            this.#resizeObserver?.disconnect();
+            this.#resizeObserver = undefined;
+        }
+        connectedCallback() {
+            this.#startResizeObserver();
+        }
+        dispose() {
+            this.#stopResizeObserver();
+        }
+    };
+})();
+export { CanvasAttributes };
+//# sourceMappingURL=CanvasAttributes.js.map

package/dist/XCanvas/XCanvas.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @deprecated this proposals cannot be implemented on other platforms
+ */
+export declare class XCanvas extends HTMLElement {
+}

package/dist/XCanvas/XCanvas.js

@@ -0,0 +1,32 @@
+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, html } from '@lynx-js/web-elements-reactive';
+import { LynxExposure } from '../common/Exposure.js';
+import { CanvasAttributes } from './CanvasAttributes.js';
+/**
+ * @deprecated this proposals cannot be implemented on other platforms
+ */
+let XCanvas = (() => {
+    let _classDecorators = [Component('x-canvas', [LynxExposure, CanvasAttributes], html `<canvas id="canvas" part="canvas"></canvas>`)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = HTMLElement;
+    var XCanvas = 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);
+            XCanvas = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return XCanvas = _classThis;
+})();
+export { XCanvas };
+//# sourceMappingURL=XCanvas.js.map

package/dist/XCanvas/index.d.ts

@@ -0,0 +1 @@
+export { XCanvas } from './XCanvas.js';

package/dist/XCanvas/index.js

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

package/dist/XFoldViewNg/XFoldviewHeaderNg.d.ts

@@ -0,0 +1,2 @@
+export declare class XFoldviewHeaderNg extends HTMLElement {
+}

package/dist/XFoldViewNg/XFoldviewHeaderNg.js

@@ -0,0 +1,32 @@
+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';
+import { XFoldviewHeaderNgFeatures } from './XFoldviewHeaderNgFeatures.js';
+let XFoldviewHeaderNg = (() => {
+    let _classDecorators = [Component('x-foldview-header-ng', [
+            LynxExposure,
+            XFoldviewHeaderNgFeatures,
+        ])];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = HTMLElement;
+    var XFoldviewHeaderNg = 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);
+            XFoldviewHeaderNg = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return XFoldviewHeaderNg = _classThis;
+})();
+export { XFoldviewHeaderNg };
+//# sourceMappingURL=XFoldviewHeaderNg.js.map

package/dist/XFoldViewNg/XFoldviewHeaderNgFeatures.d.ts

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

package/dist/XFoldViewNg/XFoldviewHeaderNgFeatures.js

@@ -0,0 +1,32 @@
+export class XFoldviewHeaderNgFeatures {
+    #dom;
+    #resizeObserver;
+    static observedAttributes = [];
+    constructor(dom) {
+        this.#dom = dom;
+    }
+    connectedCallback() {
+        this.#resizeObserver = new ResizeObserver(([resize]) => {
+            const parentElement = this.#dom.parentElement;
+            if (parentElement?.tagName === 'X-FOLDVIEW-NG') {
+                const slot = parentElement.querySelector('x-foldview-slot-ng');
+                if (slot) {
+                    const offsetTop = slot.offsetTop;
+                    const headerHeight = resize.contentRect.height;
+                    if (offsetTop < headerHeight) {
+                        slot.style.top = headerHeight - offsetTop + 'px';
+                        parentElement.__scrollableLength = headerHeight - offsetTop;
+                    }
+                }
+            }
+        });
+        this.#resizeObserver.observe(this.#dom);
+    }
+    dispose() {
+        if (this.#resizeObserver) {
+            this.#resizeObserver.disconnect();
+            this.#resizeObserver = undefined;
+        }
+    }
+}
+//# sourceMappingURL=XFoldviewHeaderNgFeatures.js.map