@lynx-js/web-elements-canary 0.9.0 → 0.9.1-canary-20251223-23796630

package/dist/XInput/XInputAttribute.js

@@ -1,4 +1,4 @@
-import { __esDecorate, __runInitializers, __setFunctionName } from "tslib";
+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
@@ -10,46 +10,45 @@ import { bindToAttribute, genDomGetter, registerAttributeHandler, } from '@lynx-
  */
 let XInputAttribute = (() => {
     let _instanceExtraInitializers = [];
-    let _private_handleValue_decorators;
-    let _private_handleValue_descriptor;
-    let _private_handleDisabled_decorators;
-    let _private_handleDisabled_initializers = [];
-    let _private_handleDisabled_extraInitializers = [];
-    let _private_handleAutocomplete_decorators;
-    let _private_handleAutocomplete_initializers = [];
-    let _private_handleAutocomplete_extraInitializers = [];
+    let __handleValue_decorators;
+    let __handleDisabled_decorators;
+    let __handleDisabled_initializers = [];
+    let __handleDisabled_extraInitializers = [];
+    let __handleAutocomplete_decorators;
+    let __handleAutocomplete_initializers = [];
+    let __handleAutocomplete_extraInitializers = [];
     return class XInputAttribute {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _private_handleValue_decorators = [registerAttributeHandler('value', false)];
-            _private_handleDisabled_decorators = [registerAttributeHandler('disabled', true)];
-            _private_handleAutocomplete_decorators = [registerAttributeHandler('autocomplete', true)];
-            __esDecorate(this, _private_handleValue_descriptor = { value: __setFunctionName(function (newValue) {
-                    if (newValue) {
-                        const maxlength = parseFloat(this.#dom.getAttribute('maxlength') ?? '');
-                        if (!isNaN(maxlength))
-                            newValue = newValue.substring(0, maxlength);
-                    }
-                    else {
-                        newValue = '';
-                    }
-                    const input = this.#getInputElement();
-                    if (input.value !== newValue) {
-                        input.value = newValue;
-                    }
-                }, "#handleValue") }, _private_handleValue_decorators, { kind: "method", name: "#handleValue", static: false, private: true, access: { has: obj => #handleValue in obj, get: obj => obj.#handleValue }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(null, null, _private_handleDisabled_decorators, { kind: "field", name: "#handleDisabled", static: false, private: true, access: { has: obj => #handleDisabled in obj, get: obj => obj.#handleDisabled, set: (obj, value) => { obj.#handleDisabled = value; } }, metadata: _metadata }, _private_handleDisabled_initializers, _private_handleDisabled_extraInitializers);
-            __esDecorate(null, null, _private_handleAutocomplete_decorators, { kind: "field", name: "#handleAutocomplete", static: false, private: true, access: { has: obj => #handleAutocomplete in obj, get: obj => obj.#handleAutocomplete, set: (obj, value) => { obj.#handleAutocomplete = value; } }, metadata: _metadata }, _private_handleAutocomplete_initializers, _private_handleAutocomplete_extraInitializers);
+            __handleValue_decorators = [registerAttributeHandler('value', false)];
+            __handleDisabled_decorators = [registerAttributeHandler('disabled', true)];
+            __handleAutocomplete_decorators = [registerAttributeHandler('autocomplete', true)];
+            __esDecorate(this, null, __handleValue_decorators, { kind: "method", name: "_handleValue", static: false, private: false, access: { has: obj => "_handleValue" in obj, get: obj => obj._handleValue }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(null, null, __handleDisabled_decorators, { kind: "field", name: "_handleDisabled", static: false, private: false, access: { has: obj => "_handleDisabled" in obj, get: obj => obj._handleDisabled, set: (obj, value) => { obj._handleDisabled = value; } }, metadata: _metadata }, __handleDisabled_initializers, __handleDisabled_extraInitializers);
+            __esDecorate(null, null, __handleAutocomplete_decorators, { kind: "field", name: "_handleAutocomplete", static: false, private: false, access: { has: obj => "_handleAutocomplete" in obj, get: obj => obj._handleAutocomplete, set: (obj, value) => { obj._handleAutocomplete = value; } }, metadata: _metadata }, __handleAutocomplete_initializers, __handleAutocomplete_extraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         static observedAttributes = ['value', 'disabled', 'autocomplete'];
         #dom = __runInitializers(this, _instanceExtraInitializers);
         #getInputElement = genDomGetter(() => this.#dom.shadowRoot, '#input');
-        get #handleValue() { return _private_handleValue_descriptor.value; }
-        #handleDisabled = __runInitializers(this, _private_handleDisabled_initializers, bindToAttribute(this.#getInputElement, 'disabled', (value) => (value !== null ? '' : null)));
-        #handleAutocomplete = (__runInitializers(this, _private_handleDisabled_extraInitializers), __runInitializers(this, _private_handleAutocomplete_initializers, bindToAttribute(this.#getInputElement, 'autocomplete')));
+        _handleValue(newValue) {
+            if (newValue) {
+                const maxlength = parseFloat(this.#dom.getAttribute('maxlength') ?? '');
+                if (!isNaN(maxlength))
+                    newValue = newValue.substring(0, maxlength);
+            }
+            else {
+                newValue = '';
+            }
+            const input = this.#getInputElement();
+            if (input.value !== newValue) {
+                input.value = newValue;
+            }
+        }
+        _handleDisabled = __runInitializers(this, __handleDisabled_initializers, bindToAttribute(this.#getInputElement, 'disabled', (value) => (value !== null ? '' : null)));
+        _handleAutocomplete = (__runInitializers(this, __handleDisabled_extraInitializers), __runInitializers(this, __handleAutocomplete_initializers, bindToAttribute(this.#getInputElement, 'autocomplete')));
         constructor(dom) {
-            __runInitializers(this, _private_handleAutocomplete_extraInitializers);
+            __runInitializers(this, __handleAutocomplete_extraInitializers);
             this.#dom = dom;
         }
     };

package/dist/XInput/XInputEvents.d.ts

@@ -2,5 +2,8 @@ import { type AttributeReactiveClass } from '@lynx-js/web-elements-reactive';
 export declare class XInputEvents implements InstanceType<AttributeReactiveClass<typeof HTMLElement>> {
     #private;
     static observedAttributes: string[];
+    _handleEnableInputEvent(status: boolean | string | null): void;
+    _handleSendComposingInput(newVal: string | null): void;
+    _handleEnableSelectionEvent(status: boolean): void;
     constructor(dom: HTMLElement);
 }

package/dist/XInput/XInputEvents.js

@@ -1,4 +1,4 @@
-import { __esDecorate, __runInitializers, __setFunctionName } from "tslib";
+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
@@ -10,42 +10,18 @@ import { renameEvent } from '../common/renameEvent.js';
 import { registerEventEnableStatusChangeHandler } from '@lynx-js/web-elements-reactive';
 let XInputEvents = (() => {
     let _instanceExtraInitializers = [];
-    let _private_handleEnableInputEvent_decorators;
-    let _private_handleEnableInputEvent_descriptor;
-    let _private_handleSendComposingInput_decorators;
-    let _private_handleSendComposingInput_descriptor;
-    let _private_handleEnableSelectionEvent_decorators;
-    let _private_handleEnableSelectionEvent_descriptor;
+    let __handleEnableInputEvent_decorators;
+    let __handleSendComposingInput_decorators;
+    let __handleEnableSelectionEvent_decorators;
     return class XInputEvents {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _private_handleEnableInputEvent_decorators = [registerAttributeHandler('input-filter', true), registerEventEnableStatusChangeHandler('lynxinput')];
-            _private_handleSendComposingInput_decorators = [registerAttributeHandler('send-composing-input', true)];
-            _private_handleEnableSelectionEvent_decorators = [registerEventEnableStatusChangeHandler('selection')];
-            __esDecorate(this, _private_handleEnableInputEvent_descriptor = { value: __setFunctionName(function (status) {
-                    const input = this.#getInputElement();
-                    if (status) {
-                        input.addEventListener('input', this.#teleportInput, { passive: true });
-                        input.addEventListener('compositionend', this.#teleportCompositionendInput, { passive: true });
-                    }
-                    else {
-                        input.removeEventListener('input', this.#teleportInput);
-                        input.removeEventListener('compositionend', this.#teleportCompositionendInput);
-                    }
-                }, "#handleEnableInputEvent") }, _private_handleEnableInputEvent_decorators, { kind: "method", name: "#handleEnableInputEvent", static: false, private: true, access: { has: obj => #handleEnableInputEvent in obj, get: obj => obj.#handleEnableInputEvent }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, _private_handleSendComposingInput_descriptor = { value: __setFunctionName(function (newVal) {
-                    this.#sendComposingInput = newVal !== null;
-                }, "#handleSendComposingInput") }, _private_handleSendComposingInput_decorators, { kind: "method", name: "#handleSendComposingInput", static: false, private: true, access: { has: obj => #handleSendComposingInput in obj, get: obj => obj.#handleSendComposingInput }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, _private_handleEnableSelectionEvent_descriptor = { value: __setFunctionName(function (status) {
-                    if (status) {
-                        this.#getInputElement().addEventListener('select', this.#selectEvent, {
-                            passive: true,
-                        });
-                    }
-                    else {
-                        this.#getInputElement().removeEventListener('select', this.#selectEvent);
-                    }
-                }, "#handleEnableSelectionEvent") }, _private_handleEnableSelectionEvent_decorators, { kind: "method", name: "#handleEnableSelectionEvent", static: false, private: true, access: { has: obj => #handleEnableSelectionEvent in obj, get: obj => obj.#handleEnableSelectionEvent }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __handleEnableInputEvent_decorators = [registerAttributeHandler('input-filter', true), registerEventEnableStatusChangeHandler('lynxinput')];
+            __handleSendComposingInput_decorators = [registerAttributeHandler('send-composing-input', true)];
+            __handleEnableSelectionEvent_decorators = [registerEventEnableStatusChangeHandler('selection')];
+            __esDecorate(this, null, __handleEnableInputEvent_decorators, { kind: "method", name: "_handleEnableInputEvent", static: false, private: false, access: { has: obj => "_handleEnableInputEvent" in obj, get: obj => obj._handleEnableInputEvent }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, __handleSendComposingInput_decorators, { kind: "method", name: "_handleSendComposingInput", static: false, private: false, access: { has: obj => "_handleSendComposingInput" in obj, get: obj => obj._handleSendComposingInput }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, __handleEnableSelectionEvent_decorators, { kind: "method", name: "_handleEnableSelectionEvent", static: false, private: false, access: { has: obj => "_handleEnableSelectionEvent" in obj, get: obj => obj._handleEnableSelectionEvent }, metadata: _metadata }, null, _instanceExtraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         static observedAttributes = ['send-composing-input', 'input-filter'];
@@ -53,8 +29,20 @@ let XInputEvents = (() => {
         #sendComposingInput = false;
         #getInputElement = genDomGetter(() => this.#dom.shadowRoot, '#input');
         #getFormElement = genDomGetter(() => this.#dom.shadowRoot, '#form');
-        get #handleEnableInputEvent() { return _private_handleEnableInputEvent_descriptor.value; }
-        get #handleSendComposingInput() { return _private_handleSendComposingInput_descriptor.value; }
+        _handleEnableInputEvent(status) {
+            const input = this.#getInputElement();
+            if (status) {
+                input.addEventListener('input', this.#teleportInput, { passive: true });
+                input.addEventListener('compositionend', this.#teleportCompositionendInput, { passive: true });
+            }
+            else {
+                input.removeEventListener('input', this.#teleportInput);
+                input.removeEventListener('compositionend', this.#teleportCompositionendInput);
+            }
+        }
+        _handleSendComposingInput(newVal) {
+            this.#sendComposingInput = newVal !== null;
+        }
         #teleportEvent = (event) => {
             const eventType = renameEvent[event.type] ?? event.type;
             this.#dom.dispatchEvent(new CustomEvent(eventType, {
@@ -112,7 +100,16 @@ let XInputEvents = (() => {
                 }));
             }
         };
-        get #handleEnableSelectionEvent() { return _private_handleEnableSelectionEvent_descriptor.value; }
+        _handleEnableSelectionEvent(status) {
+            if (status) {
+                this.#getInputElement().addEventListener('select', this.#selectEvent, {
+                    passive: true,
+                });
+            }
+            else {
+                this.#getInputElement().removeEventListener('select', this.#selectEvent);
+            }
+        }
         #selectEvent = () => {
             const input = this.#getInputElement();
             this.#dom.dispatchEvent(new CustomEvent('selection', {

package/dist/XList/ListItemAttributes.d.ts

@@ -3,5 +3,6 @@ import type { ListItem } from './ListItem.js';
 export declare class ListItemAttributes implements InstanceType<AttributeReactiveClass<typeof HTMLElement>> {
     #private;
     static observedAttributes: string[];
+    _handlerEstimatedMainAxisSizePx: (this: void, newVal: string | null) => void;
     constructor(dom: ListItem);
 }

package/dist/XList/ListItemAttributes.js

@@ -4,26 +4,25 @@ import { __esDecorate, __runInitializers } from "tslib";
 // 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, registerAttributeHandler, bindToStyle, } from '@lynx-js/web-elements-reactive';
-import { CommonEventsAndMethods } from '../common/CommonEventsAndMethods.js';
+import { registerAttributeHandler, bindToStyle, } from '@lynx-js/web-elements-reactive';
 let ListItemAttributes = (() => {
-    let _private_handlerEstimatedMainAxisSizePx_decorators;
-    let _private_handlerEstimatedMainAxisSizePx_initializers = [];
-    let _private_handlerEstimatedMainAxisSizePx_extraInitializers = [];
+    let __handlerEstimatedMainAxisSizePx_decorators;
+    let __handlerEstimatedMainAxisSizePx_initializers = [];
+    let __handlerEstimatedMainAxisSizePx_extraInitializers = [];
     return class ListItemAttributes {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _private_handlerEstimatedMainAxisSizePx_decorators = [registerAttributeHandler('estimated-main-axis-size-px', true)];
-            __esDecorate(null, null, _private_handlerEstimatedMainAxisSizePx_decorators, { kind: "field", name: "#handlerEstimatedMainAxisSizePx", static: false, private: true, access: { has: obj => #handlerEstimatedMainAxisSizePx in obj, get: obj => obj.#handlerEstimatedMainAxisSizePx, set: (obj, value) => { obj.#handlerEstimatedMainAxisSizePx = value; } }, metadata: _metadata }, _private_handlerEstimatedMainAxisSizePx_initializers, _private_handlerEstimatedMainAxisSizePx_extraInitializers);
+            __handlerEstimatedMainAxisSizePx_decorators = [registerAttributeHandler('estimated-main-axis-size-px', true)];
+            __esDecorate(null, null, __handlerEstimatedMainAxisSizePx_decorators, { kind: "field", name: "_handlerEstimatedMainAxisSizePx", static: false, private: false, access: { has: obj => "_handlerEstimatedMainAxisSizePx" in obj, get: obj => obj._handlerEstimatedMainAxisSizePx, set: (obj, value) => { obj._handlerEstimatedMainAxisSizePx = value; } }, metadata: _metadata }, __handlerEstimatedMainAxisSizePx_initializers, __handlerEstimatedMainAxisSizePx_extraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         static observedAttributes = [
             'estimated-main-axis-size-px',
         ];
         #dom;
-        #handlerEstimatedMainAxisSizePx = __runInitializers(this, _private_handlerEstimatedMainAxisSizePx_initializers, bindToStyle(() => this.#dom, '--estimated-main-axis-size-px', (v) => `${parseFloat(v)}px`));
+        _handlerEstimatedMainAxisSizePx = __runInitializers(this, __handlerEstimatedMainAxisSizePx_initializers, bindToStyle(() => this.#dom, '--estimated-main-axis-size-px', (v) => `${parseFloat(v)}px`));
         constructor(dom) {
-            __runInitializers(this, _private_handlerEstimatedMainAxisSizePx_extraInitializers);
+            __runInitializers(this, __handlerEstimatedMainAxisSizePx_extraInitializers);
             this.#dom = dom;
         }
     };

package/dist/XList/XListAttributes.d.ts

@@ -3,6 +3,8 @@ import type { XList } from './XList.js';
 export declare class XListAttributes implements InstanceType<AttributeReactiveClass<typeof HTMLElement>> {
     #private;
     static observedAttributes: string[];
+    _handlerStickyOffset: (this: void, newVal: string | null) => void;
+    _handlerCount: (this: void, newVal: string | null) => void;
     constructor(dom: XList);
     connectedCallback(): void;
 }

package/dist/XList/XListAttributes.js

@@ -6,19 +6,19 @@ import { __esDecorate, __runInitializers } from "tslib";
 */
 import { bindToStyle, boostedQueueMicrotask, registerAttributeHandler, } from '@lynx-js/web-elements-reactive';
 let XListAttributes = (() => {
-    let _private_handlerStickyOffset_decorators;
-    let _private_handlerStickyOffset_initializers = [];
-    let _private_handlerStickyOffset_extraInitializers = [];
-    let _private_handlerCount_decorators;
-    let _private_handlerCount_initializers = [];
-    let _private_handlerCount_extraInitializers = [];
+    let __handlerStickyOffset_decorators;
+    let __handlerStickyOffset_initializers = [];
+    let __handlerStickyOffset_extraInitializers = [];
+    let __handlerCount_decorators;
+    let __handlerCount_initializers = [];
+    let __handlerCount_extraInitializers = [];
     return class XListAttributes {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _private_handlerStickyOffset_decorators = [registerAttributeHandler('sticky-offset', true)];
-            _private_handlerCount_decorators = [registerAttributeHandler('span-count', true), registerAttributeHandler('column-count', true)];
-            __esDecorate(null, null, _private_handlerStickyOffset_decorators, { kind: "field", name: "#handlerStickyOffset", static: false, private: true, access: { has: obj => #handlerStickyOffset in obj, get: obj => obj.#handlerStickyOffset, set: (obj, value) => { obj.#handlerStickyOffset = value; } }, metadata: _metadata }, _private_handlerStickyOffset_initializers, _private_handlerStickyOffset_extraInitializers);
-            __esDecorate(null, null, _private_handlerCount_decorators, { kind: "field", name: "#handlerCount", static: false, private: true, access: { has: obj => #handlerCount in obj, get: obj => obj.#handlerCount, set: (obj, value) => { obj.#handlerCount = value; } }, metadata: _metadata }, _private_handlerCount_initializers, _private_handlerCount_extraInitializers);
+            __handlerStickyOffset_decorators = [registerAttributeHandler('sticky-offset', true)];
+            __handlerCount_decorators = [registerAttributeHandler('span-count', true), registerAttributeHandler('column-count', true)];
+            __esDecorate(null, null, __handlerStickyOffset_decorators, { kind: "field", name: "_handlerStickyOffset", static: false, private: false, access: { has: obj => "_handlerStickyOffset" in obj, get: obj => obj._handlerStickyOffset, set: (obj, value) => { obj._handlerStickyOffset = value; } }, metadata: _metadata }, __handlerStickyOffset_initializers, __handlerStickyOffset_extraInitializers);
+            __esDecorate(null, null, __handlerCount_decorators, { kind: "field", name: "_handlerCount", static: false, private: false, access: { has: obj => "_handlerCount" in obj, get: obj => obj._handlerCount, set: (obj, value) => { obj._handlerCount = value; } }, metadata: _metadata }, __handlerCount_initializers, __handlerCount_extraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         static observedAttributes = [
@@ -28,10 +28,10 @@ let XListAttributes = (() => {
             'column-count',
         ];
         #dom;
-        #handlerStickyOffset = __runInitializers(this, _private_handlerStickyOffset_initializers, bindToStyle(() => this.#dom, '--list-item-sticky-offset', (v) => `${parseFloat(v)}px`));
-        #handlerCount = (__runInitializers(this, _private_handlerStickyOffset_extraInitializers), __runInitializers(this, _private_handlerCount_initializers, bindToStyle(() => this.#dom, '--list-item-span-count', (v) => `${parseFloat(v)}`)));
+        _handlerStickyOffset = __runInitializers(this, __handlerStickyOffset_initializers, bindToStyle(() => this.#dom, '--list-item-sticky-offset', (v) => `${parseFloat(v)}px`));
+        _handlerCount = (__runInitializers(this, __handlerStickyOffset_extraInitializers), __runInitializers(this, __handlerCount_initializers, bindToStyle(() => this.#dom, '--list-item-span-count', (v) => `${parseFloat(v)}`)));
         constructor(dom) {
-            __runInitializers(this, _private_handlerCount_extraInitializers);
+            __runInitializers(this, __handlerCount_extraInitializers);
             this.#dom = dom;
         }
         connectedCallback() {

package/dist/XList/XListEvents.d.ts

@@ -3,5 +3,12 @@ import type { XList } from './XList.js';
 export declare class XListEvents implements InstanceType<AttributeReactiveClass<typeof HTMLElement>> {
     #private;
     static observedAttributes: string[];
+    _updateEventSwitches: (enableScrollToUpper: boolean) => void;
+    _handleUpperThresholdItemCountChange(newValue: string | null, oldValue: string | null): void;
+    _updateScrollToLowerEventSwitches: (enableScrollToLower: boolean) => void;
+    _handleLowerThresholdItemCountChange(newValue: string | null, oldValue: string | null): void;
+    _handleScrollEventsSwitches: (enabled: boolean, name: string) => void;
+    _handleScrollToUpperEdgeEventEnable: (enabled: boolean) => void;
+    _handleScrollToLowerEdgeEventEnable: (enabled: boolean) => void;
     constructor(dom: XList);
 }

package/dist/XList/XListEvents.js

@@ -1,4 +1,4 @@
-import { __esDecorate, __runInitializers, __setFunctionName } from "tslib";
+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
@@ -12,73 +12,40 @@ import { useScrollEnd } from '../common/constants.js';
 import { registerEventEnableStatusChangeHandler } from '@lynx-js/web-elements-reactive';
 let XListEvents = (() => {
     let _instanceExtraInitializers = [];
-    let _private_updateEventSwitches_decorators;
-    let _private_updateEventSwitches_initializers = [];
-    let _private_updateEventSwitches_extraInitializers = [];
-    let _private_handleUpperThresholdItemCountChange_decorators;
-    let _private_handleUpperThresholdItemCountChange_descriptor;
-    let _private_updateScrollToLowerEventSwitches_decorators;
-    let _private_updateScrollToLowerEventSwitches_initializers = [];
-    let _private_updateScrollToLowerEventSwitches_extraInitializers = [];
-    let _private_handleLowerThresholdItemCountChange_decorators;
-    let _private_handleLowerThresholdItemCountChange_descriptor;
-    let _private_handleScrollEventsSwitches_decorators;
-    let _private_handleScrollEventsSwitches_initializers = [];
-    let _private_handleScrollEventsSwitches_extraInitializers = [];
-    let _private_handleScrollToUpperEdgeEventEnable_decorators;
-    let _private_handleScrollToUpperEdgeEventEnable_initializers = [];
-    let _private_handleScrollToUpperEdgeEventEnable_extraInitializers = [];
-    let _private_handleScrollToLowerEdgeEventEnable_decorators;
-    let _private_handleScrollToLowerEdgeEventEnable_initializers = [];
-    let _private_handleScrollToLowerEdgeEventEnable_extraInitializers = [];
+    let __updateEventSwitches_decorators;
+    let __updateEventSwitches_initializers = [];
+    let __updateEventSwitches_extraInitializers = [];
+    let __handleUpperThresholdItemCountChange_decorators;
+    let __updateScrollToLowerEventSwitches_decorators;
+    let __updateScrollToLowerEventSwitches_initializers = [];
+    let __updateScrollToLowerEventSwitches_extraInitializers = [];
+    let __handleLowerThresholdItemCountChange_decorators;
+    let __handleScrollEventsSwitches_decorators;
+    let __handleScrollEventsSwitches_initializers = [];
+    let __handleScrollEventsSwitches_extraInitializers = [];
+    let __handleScrollToUpperEdgeEventEnable_decorators;
+    let __handleScrollToUpperEdgeEventEnable_initializers = [];
+    let __handleScrollToUpperEdgeEventEnable_extraInitializers = [];
+    let __handleScrollToLowerEdgeEventEnable_decorators;
+    let __handleScrollToLowerEdgeEventEnable_initializers = [];
+    let __handleScrollToLowerEdgeEventEnable_extraInitializers = [];
     return class XListEvents {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _private_updateEventSwitches_decorators = [registerEventEnableStatusChangeHandler('scrolltoupper')];
-            _private_handleUpperThresholdItemCountChange_decorators = [registerAttributeHandler('upper-threshold-item-count', true)];
-            _private_updateScrollToLowerEventSwitches_decorators = [registerEventEnableStatusChangeHandler('scrolltolower')];
-            _private_handleLowerThresholdItemCountChange_decorators = [registerAttributeHandler('lower-threshold-item-count', true)];
-            _private_handleScrollEventsSwitches_decorators = [registerEventEnableStatusChangeHandler('lynxscroll'), registerEventEnableStatusChangeHandler('lynxscrollend'), registerEventEnableStatusChangeHandler('snap')];
-            _private_handleScrollToUpperEdgeEventEnable_decorators = [registerEventEnableStatusChangeHandler('scrolltoupperedge')];
-            _private_handleScrollToLowerEdgeEventEnable_decorators = [registerEventEnableStatusChangeHandler('scrolltoloweredge')];
-            __esDecorate(this, _private_handleUpperThresholdItemCountChange_descriptor = { value: __setFunctionName(function (newValue, oldValue) {
-                    const oldItemCount = oldValue !== null
-                        ? parseFloat(oldValue)
-                        : 0;
-                    const oldObserverDom = oldItemCount === 0
-                        ? this.#getUpperThresholdObserverDom()
-                        : this.#dom.children[oldItemCount - 1];
-                    oldObserverDom && this.#upperObserver?.unobserve(oldObserverDom);
-                    const itemCount = newValue !== null
-                        ? parseFloat(newValue)
-                        : 0;
-                    const observerDom = itemCount === 0
-                        ? this.#getUpperThresholdObserverDom()
-                        : this.#dom.children[itemCount - 1];
-                    observerDom && this.#upperObserver?.observe(observerDom);
-                }, "#handleUpperThresholdItemCountChange") }, _private_handleUpperThresholdItemCountChange_decorators, { kind: "method", name: "#handleUpperThresholdItemCountChange", static: false, private: true, access: { has: obj => #handleUpperThresholdItemCountChange in obj, get: obj => obj.#handleUpperThresholdItemCountChange }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(this, _private_handleLowerThresholdItemCountChange_descriptor = { value: __setFunctionName(function (newValue, oldValue) {
-                    const oldItemCount = oldValue !== null
-                        ? parseFloat(oldValue)
-                        : 0;
-                    const oldObserverDom = oldItemCount === 0
-                        ? this.#getLowerThresholdObserverDom()
-                        : this.#dom.children[this.#dom.children.length - oldItemCount];
-                    oldObserverDom && this.#lowerObserver?.unobserve(oldObserverDom);
-                    const itemCount = newValue !== null
-                        ? parseFloat(newValue)
-                        : 0;
-                    const observerDom = itemCount === 0
-                        ? this.#getLowerThresholdObserverDom()
-                        : this.#dom.children[this.#dom.children.length
-                            - itemCount];
-                    observerDom && this.#lowerObserver?.observe(observerDom);
-                }, "#handleLowerThresholdItemCountChange") }, _private_handleLowerThresholdItemCountChange_decorators, { kind: "method", name: "#handleLowerThresholdItemCountChange", static: false, private: true, access: { has: obj => #handleLowerThresholdItemCountChange in obj, get: obj => obj.#handleLowerThresholdItemCountChange }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(null, null, _private_updateEventSwitches_decorators, { kind: "field", name: "#updateEventSwitches", static: false, private: true, access: { has: obj => #updateEventSwitches in obj, get: obj => obj.#updateEventSwitches, set: (obj, value) => { obj.#updateEventSwitches = value; } }, metadata: _metadata }, _private_updateEventSwitches_initializers, _private_updateEventSwitches_extraInitializers);
-            __esDecorate(null, null, _private_updateScrollToLowerEventSwitches_decorators, { kind: "field", name: "#updateScrollToLowerEventSwitches", static: false, private: true, access: { has: obj => #updateScrollToLowerEventSwitches in obj, get: obj => obj.#updateScrollToLowerEventSwitches, set: (obj, value) => { obj.#updateScrollToLowerEventSwitches = value; } }, metadata: _metadata }, _private_updateScrollToLowerEventSwitches_initializers, _private_updateScrollToLowerEventSwitches_extraInitializers);
-            __esDecorate(null, null, _private_handleScrollEventsSwitches_decorators, { kind: "field", name: "#handleScrollEventsSwitches", static: false, private: true, access: { has: obj => #handleScrollEventsSwitches in obj, get: obj => obj.#handleScrollEventsSwitches, set: (obj, value) => { obj.#handleScrollEventsSwitches = value; } }, metadata: _metadata }, _private_handleScrollEventsSwitches_initializers, _private_handleScrollEventsSwitches_extraInitializers);
-            __esDecorate(null, null, _private_handleScrollToUpperEdgeEventEnable_decorators, { kind: "field", name: "#handleScrollToUpperEdgeEventEnable", static: false, private: true, access: { has: obj => #handleScrollToUpperEdgeEventEnable in obj, get: obj => obj.#handleScrollToUpperEdgeEventEnable, set: (obj, value) => { obj.#handleScrollToUpperEdgeEventEnable = value; } }, metadata: _metadata }, _private_handleScrollToUpperEdgeEventEnable_initializers, _private_handleScrollToUpperEdgeEventEnable_extraInitializers);
-            __esDecorate(null, null, _private_handleScrollToLowerEdgeEventEnable_decorators, { kind: "field", name: "#handleScrollToLowerEdgeEventEnable", static: false, private: true, access: { has: obj => #handleScrollToLowerEdgeEventEnable in obj, get: obj => obj.#handleScrollToLowerEdgeEventEnable, set: (obj, value) => { obj.#handleScrollToLowerEdgeEventEnable = value; } }, metadata: _metadata }, _private_handleScrollToLowerEdgeEventEnable_initializers, _private_handleScrollToLowerEdgeEventEnable_extraInitializers);
+            __updateEventSwitches_decorators = [registerEventEnableStatusChangeHandler('scrolltoupper')];
+            __handleUpperThresholdItemCountChange_decorators = [registerAttributeHandler('upper-threshold-item-count', true)];
+            __updateScrollToLowerEventSwitches_decorators = [registerEventEnableStatusChangeHandler('scrolltolower')];
+            __handleLowerThresholdItemCountChange_decorators = [registerAttributeHandler('lower-threshold-item-count', true)];
+            __handleScrollEventsSwitches_decorators = [registerEventEnableStatusChangeHandler('lynxscroll'), registerEventEnableStatusChangeHandler('lynxscrollend'), registerEventEnableStatusChangeHandler('snap')];
+            __handleScrollToUpperEdgeEventEnable_decorators = [registerEventEnableStatusChangeHandler('scrolltoupperedge')];
+            __handleScrollToLowerEdgeEventEnable_decorators = [registerEventEnableStatusChangeHandler('scrolltoloweredge')];
+            __esDecorate(this, null, __handleUpperThresholdItemCountChange_decorators, { kind: "method", name: "_handleUpperThresholdItemCountChange", static: false, private: false, access: { has: obj => "_handleUpperThresholdItemCountChange" in obj, get: obj => obj._handleUpperThresholdItemCountChange }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, __handleLowerThresholdItemCountChange_decorators, { kind: "method", name: "_handleLowerThresholdItemCountChange", static: false, private: false, access: { has: obj => "_handleLowerThresholdItemCountChange" in obj, get: obj => obj._handleLowerThresholdItemCountChange }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(null, null, __updateEventSwitches_decorators, { kind: "field", name: "_updateEventSwitches", static: false, private: false, access: { has: obj => "_updateEventSwitches" in obj, get: obj => obj._updateEventSwitches, set: (obj, value) => { obj._updateEventSwitches = value; } }, metadata: _metadata }, __updateEventSwitches_initializers, __updateEventSwitches_extraInitializers);
+            __esDecorate(null, null, __updateScrollToLowerEventSwitches_decorators, { kind: "field", name: "_updateScrollToLowerEventSwitches", static: false, private: false, access: { has: obj => "_updateScrollToLowerEventSwitches" in obj, get: obj => obj._updateScrollToLowerEventSwitches, set: (obj, value) => { obj._updateScrollToLowerEventSwitches = value; } }, metadata: _metadata }, __updateScrollToLowerEventSwitches_initializers, __updateScrollToLowerEventSwitches_extraInitializers);
+            __esDecorate(null, null, __handleScrollEventsSwitches_decorators, { kind: "field", name: "_handleScrollEventsSwitches", static: false, private: false, access: { has: obj => "_handleScrollEventsSwitches" in obj, get: obj => obj._handleScrollEventsSwitches, set: (obj, value) => { obj._handleScrollEventsSwitches = value; } }, metadata: _metadata }, __handleScrollEventsSwitches_initializers, __handleScrollEventsSwitches_extraInitializers);
+            __esDecorate(null, null, __handleScrollToUpperEdgeEventEnable_decorators, { kind: "field", name: "_handleScrollToUpperEdgeEventEnable", static: false, private: false, access: { has: obj => "_handleScrollToUpperEdgeEventEnable" in obj, get: obj => obj._handleScrollToUpperEdgeEventEnable, set: (obj, value) => { obj._handleScrollToUpperEdgeEventEnable = value; } }, metadata: _metadata }, __handleScrollToUpperEdgeEventEnable_initializers, __handleScrollToUpperEdgeEventEnable_extraInitializers);
+            __esDecorate(null, null, __handleScrollToLowerEdgeEventEnable_decorators, { kind: "field", name: "_handleScrollToLowerEdgeEventEnable", static: false, private: false, access: { has: obj => "_handleScrollToLowerEdgeEventEnable" in obj, get: obj => obj._handleScrollToLowerEdgeEventEnable, set: (obj, value) => { obj._handleScrollToLowerEdgeEventEnable = value; } }, metadata: _metadata }, __handleScrollToLowerEdgeEventEnable_initializers, __handleScrollToLowerEdgeEventEnable_extraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         static observedAttributes = [
@@ -128,7 +95,7 @@ let XListEvents = (() => {
                 }));
             }
         };
-        #updateEventSwitches = __runInitializers(this, _private_updateEventSwitches_initializers, (enableScrollToUpper) => {
+        _updateEventSwitches = __runInitializers(this, __updateEventSwitches_initializers, (enableScrollToUpper) => {
             enableScrollToUpper
                 ? this.#dom.setAttribute('x-enable-scrolltoupper-event', '')
                 : this.#dom.removeAttribute('x-enable-scrolltoupper-event'); // css needs this;
@@ -166,8 +133,23 @@ let XListEvents = (() => {
                 });
             }
         });
-        get #handleUpperThresholdItemCountChange() { return _private_handleUpperThresholdItemCountChange_descriptor.value; }
-        #handleLowerObserver = (__runInitializers(this, _private_updateEventSwitches_extraInitializers), (entries) => {
+        _handleUpperThresholdItemCountChange(newValue, oldValue) {
+            const oldItemCount = oldValue !== null
+                ? parseFloat(oldValue)
+                : 0;
+            const oldObserverDom = oldItemCount === 0
+                ? this.#getUpperThresholdObserverDom()
+                : this.#dom.children[oldItemCount - 1];
+            oldObserverDom && this.#upperObserver?.unobserve(oldObserverDom);
+            const itemCount = newValue !== null
+                ? parseFloat(newValue)
+                : 0;
+            const observerDom = itemCount === 0
+                ? this.#getUpperThresholdObserverDom()
+                : this.#dom.children[itemCount - 1];
+            observerDom && this.#upperObserver?.observe(observerDom);
+        }
+        #handleLowerObserver = (__runInitializers(this, __updateEventSwitches_extraInitializers), (entries) => {
             const { isIntersecting } = entries[0];
             if (isIntersecting) {
                 this.#dom.dispatchEvent(new CustomEvent('scrolltolower', {
@@ -183,7 +165,7 @@ let XListEvents = (() => {
             scrolltolower: false,
             scrolltoupper: false,
         };
-        #updateScrollToLowerEventSwitches = __runInitializers(this, _private_updateScrollToLowerEventSwitches_initializers, (enableScrollToLower) => {
+        _updateScrollToLowerEventSwitches = __runInitializers(this, __updateScrollToLowerEventSwitches_initializers, (enableScrollToLower) => {
             this.#eventSwitches.scrolltolower = enableScrollToLower;
             enableScrollToLower
                 ? this.#dom.setAttribute('x-enable-scrolltolower-event', '')
@@ -221,8 +203,24 @@ let XListEvents = (() => {
                 });
             }
         });
-        get #handleLowerThresholdItemCountChange() { return _private_handleLowerThresholdItemCountChange_descriptor.value; }
-        #handleChildrenObserver = (__runInitializers(this, _private_updateScrollToLowerEventSwitches_extraInitializers), (mutationList) => {
+        _handleLowerThresholdItemCountChange(newValue, oldValue) {
+            const oldItemCount = oldValue !== null
+                ? parseFloat(oldValue)
+                : 0;
+            const oldObserverDom = oldItemCount === 0
+                ? this.#getLowerThresholdObserverDom()
+                : this.#dom.children[this.#dom.children.length - oldItemCount];
+            oldObserverDom && this.#lowerObserver?.unobserve(oldObserverDom);
+            const itemCount = newValue !== null
+                ? parseFloat(newValue)
+                : 0;
+            const observerDom = itemCount === 0
+                ? this.#getLowerThresholdObserverDom()
+                : this.#dom.children[this.#dom.children.length
+                    - itemCount];
+            observerDom && this.#lowerObserver?.observe(observerDom);
+        }
+        #handleChildrenObserver = (__runInitializers(this, __updateScrollToLowerEventSwitches_extraInitializers), (mutationList) => {
             const mutation = mutationList?.[0];
             // reset upper and lower observers
             if (mutation?.type === 'childList') {
@@ -283,7 +281,7 @@ let XListEvents = (() => {
                 detail: this.#getScrollDetail(),
             }));
         };
-        #handleScrollEventsSwitches = __runInitializers(this, _private_handleScrollEventsSwitches_initializers, (enabled, name) => {
+        _handleScrollEventsSwitches = __runInitializers(this, __handleScrollEventsSwitches_initializers, (enabled, name) => {
             this.#eventSwitches[name] =
                 enabled;
             const { lynxscroll, lynxscrollend, snap } = this.#eventSwitches;
@@ -293,7 +291,7 @@ let XListEvents = (() => {
             // cancel the previous listener first
             this.#throttledScroll
                 && listContainer.removeEventListener('scroll', this.#throttledScroll);
-            if (scroll !== null || this.#enableScrollEnd) {
+            if (lynxscroll !== null || this.#enableScrollEnd) {
                 const wait = scrollEventThrottle !== null
                     ? parseFloat(scrollEventThrottle)
                     : 0;
@@ -313,7 +311,7 @@ let XListEvents = (() => {
                 listContainer.removeEventListener('scrollend', this.#handleScrollEnd);
             }
         });
-        #handleObserver = (__runInitializers(this, _private_handleScrollEventsSwitches_extraInitializers), (entries) => {
+        #handleObserver = (__runInitializers(this, __handleScrollEventsSwitches_extraInitializers), (entries) => {
             const { isIntersecting, target } = entries[0];
             const id = target.id;
             if (isIntersecting) {
@@ -331,20 +329,20 @@ let XListEvents = (() => {
                 }
             }
         });
-        #handleScrollToUpperEdgeEventEnable = __runInitializers(this, _private_handleScrollToUpperEdgeEventEnable_initializers, (enabled) => {
+        _handleScrollToUpperEdgeEventEnable = __runInitializers(this, __handleScrollToUpperEdgeEventEnable_initializers, (enabled) => {
             enabled
                 ? this.#dom.setAttribute('x-enable-scrolltoupperedge-event', '')
                 : this.#dom.removeAttribute('x-enable-scrolltoupperedge-event'); // css needs this;
             this.#updateUpperEdgeIntersectionObserver(enabled);
         });
-        #updateUpperEdgeIntersectionObserver = (__runInitializers(this, _private_handleScrollToUpperEdgeEventEnable_extraInitializers), bindToIntersectionObserver(this.#getListContainer, this.#getUpperThresholdObserverDom, this.#handleObserver));
-        #handleScrollToLowerEdgeEventEnable = __runInitializers(this, _private_handleScrollToLowerEdgeEventEnable_initializers, (enabled) => {
+        #updateUpperEdgeIntersectionObserver = (__runInitializers(this, __handleScrollToUpperEdgeEventEnable_extraInitializers), bindToIntersectionObserver(this.#getListContainer, this.#getUpperThresholdObserverDom, this.#handleObserver));
+        _handleScrollToLowerEdgeEventEnable = __runInitializers(this, __handleScrollToLowerEdgeEventEnable_initializers, (enabled) => {
             enabled
                 ? this.#dom.setAttribute('x-enable-scrolltoloweredge-event', '')
                 : this.#dom.removeAttribute('x-enable-scrolltoloweredge-event'); // css needs this;
             this.#updateLowerEdgeIntersectionObserver(enabled);
         });
-        #updateLowerEdgeIntersectionObserver = (__runInitializers(this, _private_handleScrollToLowerEdgeEventEnable_extraInitializers), bindToIntersectionObserver(this.#getListContainer, this.#getLowerThresholdObserverDom, this.#handleObserver));
+        #updateLowerEdgeIntersectionObserver = (__runInitializers(this, __handleScrollToLowerEdgeEventEnable_extraInitializers), bindToIntersectionObserver(this.#getListContainer, this.#getLowerThresholdObserverDom, this.#handleObserver));
         #handleScrollEnd = () => {
             const itemSnap = this.#dom.getAttribute('item-snap');
             this.#dom.dispatchEvent(new CustomEvent('lynxscrollend', {

package/dist/XList/XListWaterfall.d.ts

@@ -3,5 +3,7 @@ import type { XList } from './XList.js';
 export declare class XListWaterfall implements InstanceType<AttributeReactiveClass<typeof HTMLElement>> {
     #private;
     static observedAttributes: string[];
+    _handleXEnableHeaderOffsetEvent(enableScrollToLower: boolean): void;
     constructor(dom: XList);
+    _handlerListType(newVal: string | null): void;
 }