@lynx-js/web-elements 0.2.4

package/dist/XTextarea/Placeholder.js

@@ -0,0 +1,59 @@
+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, bindToStyle, genDomGetter, registerAttributeHandler, } from '@lynx-js/web-elements-reactive';
+let Placeholder = (() => {
+    let _private_updatePlaceholderColor_decorators;
+    let _private_updatePlaceholderColor_initializers = [];
+    let _private_updatePlaceholderColor_extraInitializers = [];
+    let _private_updatePlaceholderFontSize_decorators;
+    let _private_updatePlaceholderFontSize_initializers = [];
+    let _private_updatePlaceholderFontSize_extraInitializers = [];
+    let _private_updatePlaceholderFontWeight_decorators;
+    let _private_updatePlaceholderFontWeight_initializers = [];
+    let _private_updatePlaceholderFontWeight_extraInitializers = [];
+    let _private_updatePlaceholderFontFamily_decorators;
+    let _private_updatePlaceholderFontFamily_initializers = [];
+    let _private_updatePlaceholderFontFamily_extraInitializers = [];
+    let _private_handlePlaceholder_decorators;
+    let _private_handlePlaceholder_initializers = [];
+    let _private_handlePlaceholder_extraInitializers = [];
+    return class Placeholder {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _private_updatePlaceholderColor_decorators = [registerAttributeHandler('placeholder-color', true)];
+            _private_updatePlaceholderFontSize_decorators = [registerAttributeHandler('placeholder-font-size', true)];
+            _private_updatePlaceholderFontWeight_decorators = [registerAttributeHandler('placeholder-font-weight', true)];
+            _private_updatePlaceholderFontFamily_decorators = [registerAttributeHandler('placeholder-font-family', true)];
+            _private_handlePlaceholder_decorators = [registerAttributeHandler('placeholder', true)];
+            __esDecorate(null, null, _private_updatePlaceholderColor_decorators, { kind: "field", name: "#updatePlaceholderColor", static: false, private: true, access: { has: obj => #updatePlaceholderColor in obj, get: obj => obj.#updatePlaceholderColor, set: (obj, value) => { obj.#updatePlaceholderColor = value; } }, metadata: _metadata }, _private_updatePlaceholderColor_initializers, _private_updatePlaceholderColor_extraInitializers);
+            __esDecorate(null, null, _private_updatePlaceholderFontSize_decorators, { kind: "field", name: "#updatePlaceholderFontSize", static: false, private: true, access: { has: obj => #updatePlaceholderFontSize in obj, get: obj => obj.#updatePlaceholderFontSize, set: (obj, value) => { obj.#updatePlaceholderFontSize = value; } }, metadata: _metadata }, _private_updatePlaceholderFontSize_initializers, _private_updatePlaceholderFontSize_extraInitializers);
+            __esDecorate(null, null, _private_updatePlaceholderFontWeight_decorators, { kind: "field", name: "#updatePlaceholderFontWeight", static: false, private: true, access: { has: obj => #updatePlaceholderFontWeight in obj, get: obj => obj.#updatePlaceholderFontWeight, set: (obj, value) => { obj.#updatePlaceholderFontWeight = value; } }, metadata: _metadata }, _private_updatePlaceholderFontWeight_initializers, _private_updatePlaceholderFontWeight_extraInitializers);
+            __esDecorate(null, null, _private_updatePlaceholderFontFamily_decorators, { kind: "field", name: "#updatePlaceholderFontFamily", static: false, private: true, access: { has: obj => #updatePlaceholderFontFamily in obj, get: obj => obj.#updatePlaceholderFontFamily, set: (obj, value) => { obj.#updatePlaceholderFontFamily = value; } }, metadata: _metadata }, _private_updatePlaceholderFontFamily_initializers, _private_updatePlaceholderFontFamily_extraInitializers);
+            __esDecorate(null, null, _private_handlePlaceholder_decorators, { kind: "field", name: "#handlePlaceholder", static: false, private: true, access: { has: obj => #handlePlaceholder in obj, get: obj => obj.#handlePlaceholder, set: (obj, value) => { obj.#handlePlaceholder = value; } }, metadata: _metadata }, _private_handlePlaceholder_initializers, _private_handlePlaceholder_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static observedAttributes = [
+            'placeholder',
+            'placeholder-color',
+            'placeholder-font-size',
+            'placeholder-font-weight',
+            'placeholder-font-family',
+        ];
+        #getTextarea = genDomGetter(() => this.#dom.shadowRoot, '#textarea');
+        #updatePlaceholderColor = __runInitializers(this, _private_updatePlaceholderColor_initializers, bindToStyle(this.#getTextarea, '--placeholder-color', undefined, true));
+        #updatePlaceholderFontSize = (__runInitializers(this, _private_updatePlaceholderColor_extraInitializers), __runInitializers(this, _private_updatePlaceholderFontSize_initializers, bindToStyle(this.#getTextarea, '--placeholder-font-size', undefined, true)));
+        #updatePlaceholderFontWeight = (__runInitializers(this, _private_updatePlaceholderFontSize_extraInitializers), __runInitializers(this, _private_updatePlaceholderFontWeight_initializers, bindToStyle(this.#getTextarea, '--placeholder-font-weight', undefined, true)));
+        #updatePlaceholderFontFamily = (__runInitializers(this, _private_updatePlaceholderFontWeight_extraInitializers), __runInitializers(this, _private_updatePlaceholderFontFamily_initializers, bindToStyle(this.#getTextarea, '--placeholder-font-family', undefined, true)));
+        #handlePlaceholder = (__runInitializers(this, _private_updatePlaceholderFontFamily_extraInitializers), __runInitializers(this, _private_handlePlaceholder_initializers, bindToAttribute(this.#getTextarea, 'placeholder')));
+        #dom = __runInitializers(this, _private_handlePlaceholder_extraInitializers);
+        constructor(dom) {
+            this.#dom = dom;
+        }
+    };
+})();
+export { Placeholder };
+//# sourceMappingURL=Placeholder.js.map

package/dist/XTextarea/TextareaBaseAttributes.d.ts

@@ -0,0 +1,6 @@
+import { AttributeReactiveClass } from '@lynx-js/web-elements-reactive';
+export declare class TextareaBaseAttributes implements InstanceType<AttributeReactiveClass<typeof HTMLElement>> {
+    #private;
+    static observedAttributes: string[];
+    constructor(dom: HTMLElement);
+}

package/dist/XTextarea/TextareaBaseAttributes.js

@@ -0,0 +1,70 @@
+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';
+let TextareaBaseAttributes = (() => {
+    let _private_handlerConfirmType_decorators;
+    let _private_handlerConfirmType_initializers = [];
+    let _private_handlerConfirmType_extraInitializers = [];
+    let _private_handlerMaxlength_decorators;
+    let _private_handlerMaxlength_initializers = [];
+    let _private_handlerMaxlength_extraInitializers = [];
+    let _private_handleReadonly_decorators;
+    let _private_handleReadonly_initializers = [];
+    let _private_handleReadonly_extraInitializers = [];
+    let _private_handleSpellCheck_decorators;
+    let _private_handleSpellCheck_initializers = [];
+    let _private_handleSpellCheck_extraInitializers = [];
+    let _private_handleShowSoftInputOnfocus_decorators;
+    let _private_handleShowSoftInputOnfocus_initializers = [];
+    let _private_handleShowSoftInputOnfocus_extraInitializers = [];
+    return class TextareaBaseAttributes {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _private_handlerConfirmType_decorators = [registerAttributeHandler('confirm-type', true)];
+            _private_handlerMaxlength_decorators = [registerAttributeHandler('maxlength', true)];
+            _private_handleReadonly_decorators = [registerAttributeHandler('readonly', true)];
+            _private_handleSpellCheck_decorators = [registerAttributeHandler('ios-spell-check', true)];
+            _private_handleShowSoftInputOnfocus_decorators = [registerAttributeHandler('show-soft-input-onfocus', true)];
+            __esDecorate(null, null, _private_handlerConfirmType_decorators, { kind: "field", name: "#handlerConfirmType", static: false, private: true, access: { has: obj => #handlerConfirmType in obj, get: obj => obj.#handlerConfirmType, set: (obj, value) => { obj.#handlerConfirmType = value; } }, metadata: _metadata }, _private_handlerConfirmType_initializers, _private_handlerConfirmType_extraInitializers);
+            __esDecorate(null, null, _private_handlerMaxlength_decorators, { kind: "field", name: "#handlerMaxlength", static: false, private: true, access: { has: obj => #handlerMaxlength in obj, get: obj => obj.#handlerMaxlength, set: (obj, value) => { obj.#handlerMaxlength = value; } }, metadata: _metadata }, _private_handlerMaxlength_initializers, _private_handlerMaxlength_extraInitializers);
+            __esDecorate(null, null, _private_handleReadonly_decorators, { kind: "field", name: "#handleReadonly", static: false, private: true, access: { has: obj => #handleReadonly in obj, get: obj => obj.#handleReadonly, set: (obj, value) => { obj.#handleReadonly = value; } }, metadata: _metadata }, _private_handleReadonly_initializers, _private_handleReadonly_extraInitializers);
+            __esDecorate(null, null, _private_handleSpellCheck_decorators, { kind: "field", name: "#handleSpellCheck", static: false, private: true, access: { has: obj => #handleSpellCheck in obj, get: obj => obj.#handleSpellCheck, set: (obj, value) => { obj.#handleSpellCheck = value; } }, metadata: _metadata }, _private_handleSpellCheck_initializers, _private_handleSpellCheck_extraInitializers);
+            __esDecorate(null, null, _private_handleShowSoftInputOnfocus_decorators, { kind: "field", name: "#handleShowSoftInputOnfocus", static: false, private: true, access: { has: obj => #handleShowSoftInputOnfocus in obj, get: obj => obj.#handleShowSoftInputOnfocus, set: (obj, value) => { obj.#handleShowSoftInputOnfocus = value; } }, metadata: _metadata }, _private_handleShowSoftInputOnfocus_initializers, _private_handleShowSoftInputOnfocus_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static observedAttributes = [
+            'confirm-type',
+            'maxlength',
+            'readonly',
+            'type',
+            'ios-spell-check',
+            'spell-check',
+            'show-soft-input-onfocus',
+        ];
+        #dom;
+        #getTextareaElement = genDomGetter(() => this.#dom.shadowRoot, '#textarea');
+        #handlerConfirmType = __runInitializers(this, _private_handlerConfirmType_initializers, bindToAttribute(this.#getTextareaElement, 'enterkeyhint', (val) => {
+            if (val === null)
+                return 'send';
+            return val;
+        }));
+        #handlerMaxlength = (__runInitializers(this, _private_handlerConfirmType_extraInitializers), __runInitializers(this, _private_handlerMaxlength_initializers, bindToAttribute(this.#getTextareaElement, 'maxlength', (val) => {
+            if (val === null)
+                return '140';
+            return val;
+        })));
+        #handleReadonly = (__runInitializers(this, _private_handlerMaxlength_extraInitializers), __runInitializers(this, _private_handleReadonly_initializers, bindToAttribute(this.#getTextareaElement, 'readonly', (value) => (value !== null ? '' : null))));
+        #handleSpellCheck = (__runInitializers(this, _private_handleReadonly_extraInitializers), __runInitializers(this, _private_handleSpellCheck_initializers, bindToAttribute(this.#getTextareaElement, 'spellcheck', (value) => (value === null ? 'false' : 'true'))));
+        #handleShowSoftInputOnfocus = (__runInitializers(this, _private_handleSpellCheck_extraInitializers), __runInitializers(this, _private_handleShowSoftInputOnfocus_initializers, bindToAttribute(this.#getTextareaElement, 'virtualkeyboardpolicy', (value) => (value === null ? 'manual' : 'auto'))));
+        constructor(dom) {
+            __runInitializers(this, _private_handleShowSoftInputOnfocus_extraInitializers);
+            this.#dom = dom;
+        }
+    };
+})();
+export { TextareaBaseAttributes };
+//# sourceMappingURL=TextareaBaseAttributes.js.map

package/dist/XTextarea/XTextarea.d.ts

@@ -0,0 +1,21 @@
+export declare class XTextarea extends HTMLElement {
+    #private;
+    get value(): string;
+    set value(val: string);
+    addText(params: {
+        text: string;
+    }): void;
+    setValue(params: {
+        value: string;
+        index: number;
+    }): void;
+    sendDelEvent(params: {
+        action: number;
+        length: number;
+    }): void;
+    select(): void;
+    setSelectionRange(params: {
+        selectionStart: number;
+        selectionEnd: number;
+    }): void;
+}

package/dist/XTextarea/XTextarea.js

@@ -0,0 +1,101 @@
+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, genDomGetter, html } from '@lynx-js/web-elements-reactive';
+import { Placeholder } from './Placeholder.js';
+import { TextareaBaseAttributes } from './TextareaBaseAttributes.js';
+import { XTextareaAttributes } from './XTextareaAttributes.js';
+import { XTextareaEvents } from './XTextareaEvents.js';
+import { LynxExposure } from '../common/Exposure.js';
+// x-textarea
+let XTextarea = (() => {
+    let _classDecorators = [Component('x-textarea', [
+            LynxExposure,
+            Placeholder,
+            TextareaBaseAttributes,
+            XTextareaAttributes,
+            XTextareaEvents,
+        ], html `<style>
+      #textarea:focus,
+      #textarea:focus-visible {
+        border: inherit;
+        outline: inherit;
+      }
+    </style>
+    <form id="form" part="form" method="dialog">
+      <textarea id="textarea" part="textarea"></textarea>
+    </form> `)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = HTMLElement;
+    var XTextarea = 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);
+            XTextarea = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        #getTextarea = genDomGetter(() => this.shadowRoot, '#textarea');
+        get value() {
+            return this.#getTextarea().value;
+        }
+        set value(val) {
+            this.#getTextarea().value = val;
+        }
+        addText(params) {
+            const { text } = params;
+            const input = this.#getTextarea();
+            const selectionStart = input.selectionStart;
+            if (selectionStart === null) {
+                input.value = text;
+            }
+            else {
+                const currentValue = input.value;
+                input.value = currentValue.slice(0, selectionStart)
+                    + text
+                    + currentValue.slice(selectionStart);
+            }
+        }
+        setValue(params) {
+            const input = this.#getTextarea();
+            input.value = params.value;
+            let cursorIndex;
+            if ((cursorIndex = params.index)) {
+                input.setSelectionRange(cursorIndex, cursorIndex);
+            }
+        }
+        sendDelEvent(params) {
+            let { action, length } = params;
+            const input = this.#getTextarea();
+            if (action === 1) {
+                length = 1;
+            }
+            const selectionStart = input.selectionStart;
+            if (selectionStart === null) {
+                const currentValue = input.value;
+                input.value = input.value.substring(0, currentValue.length - length);
+            }
+            else {
+                const currentValue = input.value;
+                input.value = currentValue.slice(0, selectionStart - length)
+                    + currentValue.slice(selectionStart);
+            }
+        }
+        select() {
+            const input = this.#getTextarea();
+            input.setSelectionRange(0, input.value.length);
+        }
+        setSelectionRange(params) {
+            this.#getTextarea().setSelectionRange(params.selectionStart, params.selectionEnd);
+        }
+    };
+    return XTextarea = _classThis;
+})();
+export { XTextarea };
+//# sourceMappingURL=XTextarea.js.map

package/dist/XTextarea/XTextareaAttributes.d.ts

@@ -0,0 +1,6 @@
+import { AttributeReactiveClass } from '@lynx-js/web-elements-reactive';
+export declare class XTextareaAttributes implements InstanceType<AttributeReactiveClass<typeof HTMLElement>> {
+    #private;
+    static observedAttributes: string[];
+    constructor(dom: HTMLElement);
+}

package/dist/XTextarea/XTextareaAttributes.js

@@ -0,0 +1,81 @@
+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 { bindToAttribute, genDomGetter, registerAttributeHandler, bindToStyle, } from '@lynx-js/web-elements-reactive';
+let XTextareaAttributes = (() => {
+    let _instanceExtraInitializers = [];
+    let _private_handleConfirmEnter_decorators;
+    let _private_handleConfirmEnter_descriptor;
+    let _private_handleDisabled_decorators;
+    let _private_handleDisabled_initializers = [];
+    let _private_handleDisabled_extraInitializers = [];
+    let _private_handleMaxHeight_decorators;
+    let _private_handleMaxHeight_initializers = [];
+    let _private_handleMaxHeight_extraInitializers = [];
+    let _private_handleMinHeight_decorators;
+    let _private_handleMinHeight_initializers = [];
+    let _private_handleMinHeight_extraInitializers = [];
+    let _private_handleValue_decorators;
+    let _private_handleValue_descriptor;
+    return class XTextareaAttributes {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _private_handleConfirmEnter_decorators = [registerAttributeHandler('confirm-enter', true)];
+            _private_handleDisabled_decorators = [registerAttributeHandler('disabled', true)];
+            _private_handleMaxHeight_decorators = [registerAttributeHandler('max-height', true)];
+            _private_handleMinHeight_decorators = [registerAttributeHandler('min-height', true)];
+            _private_handleValue_decorators = [registerAttributeHandler('value', false)];
+            __esDecorate(this, _private_handleConfirmEnter_descriptor = { value: __setFunctionName(function (newVal) {
+                    this.#confirmEnter = newVal !== null;
+                }, "#handleConfirmEnter") }, _private_handleConfirmEnter_decorators, { kind: "method", name: "#handleConfirmEnter", static: false, private: true, access: { has: obj => #handleConfirmEnter in obj, get: obj => obj.#handleConfirmEnter }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __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 textarea = this.#getTextareaElement();
+                    if (textarea.value !== newValue) {
+                        textarea.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_handleMaxHeight_decorators, { kind: "field", name: "#handleMaxHeight", static: false, private: true, access: { has: obj => #handleMaxHeight in obj, get: obj => obj.#handleMaxHeight, set: (obj, value) => { obj.#handleMaxHeight = value; } }, metadata: _metadata }, _private_handleMaxHeight_initializers, _private_handleMaxHeight_extraInitializers);
+            __esDecorate(null, null, _private_handleMinHeight_decorators, { kind: "field", name: "#handleMinHeight", static: false, private: true, access: { has: obj => #handleMinHeight in obj, get: obj => obj.#handleMinHeight, set: (obj, value) => { obj.#handleMinHeight = value; } }, metadata: _metadata }, _private_handleMinHeight_initializers, _private_handleMinHeight_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static observedAttributes = [
+            'confirm-enter',
+            'disabled',
+            'max-height',
+            'min-height',
+            'value',
+        ];
+        #dom = __runInitializers(this, _instanceExtraInitializers);
+        #getTextareaElement = genDomGetter(() => this.#dom.shadowRoot, '#textarea');
+        #getFormElement = genDomGetter(() => this.#dom.shadowRoot, '#form');
+        #confirmEnter = false;
+        get #handleConfirmEnter() { return _private_handleConfirmEnter_descriptor.value; }
+        #handleDisabled = __runInitializers(this, _private_handleDisabled_initializers, bindToAttribute(this.#getTextareaElement, 'disabled', (value) => (value !== null ? '' : null)));
+        #handleMaxHeight = (__runInitializers(this, _private_handleDisabled_extraInitializers), __runInitializers(this, _private_handleMaxHeight_initializers, bindToStyle(this.#getTextareaElement, 'max-height')));
+        #handleMinHeight = (__runInitializers(this, _private_handleMaxHeight_extraInitializers), __runInitializers(this, _private_handleMinHeight_initializers, bindToStyle(this.#getTextareaElement, 'min-height')));
+        get #handleValue() { return _private_handleValue_descriptor.value; }
+        #handleKeyEvent = (__runInitializers(this, _private_handleMinHeight_extraInitializers), (event) => {
+            if (this.#confirmEnter && event.key === 'Enter') {
+                this.#getFormElement().dispatchEvent(new SubmitEvent('submit'));
+            }
+        });
+        constructor(dom) {
+            this.#dom = dom;
+            this.#getTextareaElement().addEventListener('keyup', this.#handleKeyEvent);
+        }
+    };
+})();
+export { XTextareaAttributes };
+//# sourceMappingURL=XTextareaAttributes.js.map

package/dist/XTextarea/XTextareaEvents.d.ts

@@ -0,0 +1,6 @@
+import { AttributeReactiveClass } from '@lynx-js/web-elements-reactive';
+export declare class XTextareaEvents implements InstanceType<AttributeReactiveClass<typeof HTMLElement>> {
+    #private;
+    static observedAttributes: string[];
+    constructor(dom: HTMLElement);
+}

package/dist/XTextarea/XTextareaEvents.js

@@ -0,0 +1,111 @@
+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 { renameEvent } from '../common/renameEvent.js';
+let XTextareaEvents = (() => {
+    let _instanceExtraInitializers = [];
+    let _private_handleEnableConfirmEvent_decorators;
+    let _private_handleEnableConfirmEvent_descriptor;
+    let _private_handleSendComposingInput_decorators;
+    let _private_handleSendComposingInput_descriptor;
+    return class XTextareaEvents {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _private_handleEnableConfirmEvent_decorators = [registerAttributeHandler('x-enable-input-event', true)];
+            _private_handleSendComposingInput_decorators = [registerAttributeHandler('send-composing-input', true)];
+            __esDecorate(this, _private_handleEnableConfirmEvent_descriptor = { value: __setFunctionName(function (newValue) {
+                    const textareaElement = this.#getTextareaElement();
+                    if (newValue !== null) {
+                        textareaElement.addEventListener('input', this.#teleportInput, { passive: true });
+                        textareaElement.addEventListener('compositionend', this.#teleportCompositionendInput, { passive: true });
+                    }
+                    else {
+                        textareaElement.removeEventListener('input', this.#teleportInput);
+                        textareaElement.removeEventListener('compositionend', this.#teleportCompositionendInput);
+                    }
+                }, "#handleEnableConfirmEvent") }, _private_handleEnableConfirmEvent_decorators, { kind: "method", name: "#handleEnableConfirmEvent", static: false, private: true, access: { has: obj => #handleEnableConfirmEvent in obj, get: obj => obj.#handleEnableConfirmEvent }, 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);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static observedAttributes = ['x-enable-input-event', 'send-composing-input'];
+        #dom = __runInitializers(this, _instanceExtraInitializers);
+        #sendComposingInput = false;
+        #getTextareaElement = genDomGetter(() => this.#dom.shadowRoot, '#textarea');
+        #getFormElement = genDomGetter(() => this.#dom.shadowRoot, '#form');
+        get #handleEnableConfirmEvent() { return _private_handleEnableConfirmEvent_descriptor.value; }
+        get #handleSendComposingInput() { return _private_handleSendComposingInput_descriptor.value; }
+        #teleportEvent = (event) => {
+            const eventType = renameEvent[event.type] ?? event.type;
+            this.#dom.dispatchEvent(new CustomEvent(eventType, {
+                ...commonComponentEventSetting,
+                detail: {
+                    value: this.#getTextareaElement().value,
+                },
+            }));
+        };
+        #teleportInput = (event) => {
+            const input = this.#getTextareaElement();
+            const value = input.value;
+            const isComposing = event.isComposing;
+            if (isComposing && !this.#sendComposingInput)
+                return;
+            this.#dom.dispatchEvent(new CustomEvent('input', {
+                ...commonComponentEventSetting,
+                detail: {
+                    value,
+                    textLength: value.length,
+                    cursor: input.selectionStart,
+                    isComposing,
+                },
+            }));
+        };
+        #teleportCompositionendInput = () => {
+            const input = this.#getTextareaElement();
+            const value = input.value;
+            // if #sendComposingInput set true, #teleportInput will send detail
+            if (!this.#sendComposingInput) {
+                this.#dom.dispatchEvent(new CustomEvent('input', {
+                    ...commonComponentEventSetting,
+                    detail: {
+                        value,
+                        textLength: value.length,
+                        cursor: input.selectionStart,
+                    },
+                }));
+            }
+        };
+        #blockHtmlEvent = (event) => {
+            if (event.target === this.#getTextareaElement()
+                && typeof event.detail === 'number') {
+                event.stopImmediatePropagation();
+            }
+        };
+        constructor(dom) {
+            this.#dom = dom;
+            const textareaElement = this.#getTextareaElement();
+            const formElement = this.#getFormElement();
+            textareaElement.addEventListener('blur', this.#teleportEvent, {
+                passive: true,
+            });
+            textareaElement.addEventListener('focus', this.#teleportEvent, {
+                passive: true,
+            });
+            formElement.addEventListener('submit', this.#teleportEvent, {
+                passive: true,
+            });
+            // use form to stop propagation
+            formElement.addEventListener('input', this.#blockHtmlEvent, {
+                passive: true,
+            });
+        }
+    };
+})();
+export { XTextareaEvents };
+//# sourceMappingURL=XTextareaEvents.js.map

package/dist/XTextarea/index.d.ts

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

package/dist/XTextarea/index.js

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

package/dist/XView/BlurRadius.d.ts

@@ -0,0 +1,7 @@
+import { AttributeReactiveClass } from '@lynx-js/web-elements-reactive';
+import { XBlurView } from './XBlurView.js';
+export declare class BlurRadius implements InstanceType<AttributeReactiveClass<typeof XBlurView>> {
+    #private;
+    static observedAttributes: string[];
+    constructor(dom: HTMLElement);
+}

package/dist/XView/BlurRadius.js

@@ -0,0 +1,38 @@
+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';
+let BlurRadius = (() => {
+    let _instanceExtraInitializers = [];
+    let _private_handleBlurRadius_decorators;
+    let _private_handleBlurRadius_descriptor;
+    return class BlurRadius {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _private_handleBlurRadius_decorators = [registerAttributeHandler('blur-radius', true)];
+            __esDecorate(this, _private_handleBlurRadius_descriptor = { value: __setFunctionName(function (newVal) {
+                    if (newVal) {
+                        newVal = `blur(${parseFloat(newVal)}px)`;
+                        this.#getDynamicStyle().innerHTML =
+                            `:host { backdrop-filter: ${newVal}; -webkit-backdrop-filter: ${newVal}}`;
+                    }
+                    else {
+                        this.#getDynamicStyle().innerHTML = '';
+                    }
+                }, "#handleBlurRadius") }, _private_handleBlurRadius_decorators, { kind: "method", name: "#handleBlurRadius", static: false, private: true, access: { has: obj => #handleBlurRadius in obj, get: obj => obj.#handleBlurRadius }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static observedAttributes = ['blur-radius'];
+        #dom = __runInitializers(this, _instanceExtraInitializers);
+        #getDynamicStyle = genDomGetter(() => this.#dom.shadowRoot, '#dynamic-style');
+        get #handleBlurRadius() { return _private_handleBlurRadius_descriptor.value; }
+        constructor(dom) {
+            this.#dom = dom;
+        }
+    };
+})();
+export { BlurRadius };
+//# sourceMappingURL=BlurRadius.js.map

package/dist/XView/XBlurView.d.ts

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

package/dist/XView/XBlurView.js

@@ -0,0 +1,29 @@
+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 { BlurRadius } from './BlurRadius.js';
+let XBlurView = (() => {
+    let _classDecorators = [Component('x-blur-view', [LynxExposure, BlurRadius], `<style id="dynamic-style"></style><slot></slot>`)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = HTMLElement;
+    var XBlurView = 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);
+            XBlurView = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return XBlurView = _classThis;
+})();
+export { XBlurView };
+//# sourceMappingURL=XBlurView.js.map

package/dist/XView/XView.d.ts

@@ -0,0 +1,4 @@
+export declare class XView extends HTMLElement {
+    superScrollIntoView(arg?: boolean | ScrollIntoViewOptions | undefined): void;
+    scrollIntoView(arg?: boolean | ScrollIntoViewOptions | undefined): void;
+}

package/dist/XView/XView.js

@@ -0,0 +1,45 @@
+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 { ScrollIntoView } from '../ScrollView/ScrollIntoView.js';
+import { LynxExposure } from '../common/Exposure.js';
+let XView = (() => {
+    let _classDecorators = [Component('x-view', [LynxExposure])];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = HTMLElement;
+    var XView = 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);
+            XView = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        superScrollIntoView(arg) {
+            super.scrollIntoView(arg);
+        }
+        scrollIntoView(arg) {
+            const lynxArg = arg;
+            if (typeof arg === 'object' && lynxArg.scrollIntoViewOptions) {
+                this.dispatchEvent(new CustomEvent(ScrollIntoView.eventName, {
+                    bubbles: true,
+                    composed: true,
+                    detail: lynxArg.scrollIntoViewOptions,
+                }));
+            }
+            else {
+                super.scrollIntoView(arg);
+            }
+        }
+    };
+    return XView = _classThis;
+})();
+export { XView };
+//# sourceMappingURL=XView.js.map

package/dist/XView/index.d.ts

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

package/dist/XView/index.js

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

package/dist/XViewpagerNg/XViewpagerItemNg.d.ts

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