@nuralyui/textarea 0.1.0

package/textarea.component.js

@@ -0,0 +1,670 @@
+/**
+ * @license
+ * Copyright 2023 Nuraly, Laabidi Aymen
+ * SPDX-License-Identifier: MIT
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { LitElement, html } from 'lit';
+import { customElement, property, state, query } from 'lit/decorators.js';
+import { styles } from './textarea.style.js';
+import '../icon/icon.component.js';
+import { TEXTAREA_DEFAULTS, EMPTY_STRING } from './textarea.types.js';
+import { NuralyUIBaseMixin } from '../../shared/base-mixin.js';
+import { TextareaValidationController, TextareaEventController } from './controllers/index.js';
+/**
+ * Versatile textarea component with validation, resize options, and interactive features.
+ *
+ * @example
+ * ```html
+ * <nr-textarea placeholder="Enter your message"></nr-textarea>
+ * <nr-textarea rows="5" resize="vertical"></nr-textarea>
+ * <nr-textarea max-length="500" show-count></nr-textarea>
+ * ```
+ *
+ * @fires nr-textarea-change - Value changes
+ * @fires nr-focus - Textarea focused
+ * @fires nr-blur - Textarea blurred
+ * @fires nr-clear - Clear button clicked
+ * @fires nr-resize - Textarea resized
+ *
+ * @slot label - Textarea label
+ * @slot helper-text - Helper text
+ * @slot addon-before - Content before textarea
+ * @slot addon-after - Content after textarea
+ */
+let NrTextareaElement = class NrTextareaElement extends NuralyUIBaseMixin(LitElement) {
+    constructor() {
+        super();
+        // Controllers
+        this.validationController = new TextareaValidationController(this);
+        this.eventController = new TextareaEventController(this);
+        /** Disables the textarea */
+        this.disabled = false;
+        /** Makes the textarea read-only */
+        this.readonly = false;
+        /** Visual state (default, success, warning, error) */
+        this.state = "default" /* TEXTAREA_STATE.Default */;
+        /** Current textarea value */
+        this.value = EMPTY_STRING;
+        /** Textarea size (small, medium, large) */
+        this.size = "medium" /* TEXTAREA_SIZE.Medium */;
+        /** Visual variant (outlined, underlined, filled) */
+        this.variant = "underlined" /* TEXTAREA_VARIANT.Underlined */;
+        /** Resize behavior (none, vertical, horizontal, both) */
+        this.resize = "vertical" /* TEXTAREA_RESIZE.Vertical */;
+        /** Number of visible text lines */
+        this.rows = TEXTAREA_DEFAULTS.ROWS;
+        /** Number of visible character columns */
+        this.cols = TEXTAREA_DEFAULTS.COLS;
+        /** Placeholder text */
+        this.placeholder = EMPTY_STRING;
+        /** HTML autocomplete attribute */
+        this.autocomplete = 'off';
+        /** Shows clear button */
+        this.allowClear = false;
+        /** Shows character counter */
+        this.showCount = false;
+        /** Auto-resize textarea based on content */
+        this.autoResize = false;
+        /** Array of validation rules */
+        this.rules = [];
+        /** Validate on change */
+        this.validateOnChange = true;
+        /** Validate on blur */
+        this.validateOnBlur = true;
+        /** Show validation status icon */
+        this.hasFeedback = false;
+        this.isFocused = false;
+        this.characterCount = 0;
+        // Initialize character count based on initial value
+        this.characterCount = this.value.length;
+        // Setup controller event listeners
+        this.setupControllerListeners();
+    }
+    /** Clearable alias for controller interface compatibility */
+    get clearable() {
+        return this.allowClear;
+    }
+    /**
+     * Setup controller event listeners
+     */
+    setupControllerListeners() {
+        // Validation events
+        this.addEventListener('textarea-validation', (e) => {
+            this.validationResult = e.detail.validationResult;
+        });
+        // Input events  
+        this.addEventListener('textarea-input', (e) => {
+            this.handleControllerInput(e.detail.value);
+        });
+        // Focus/blur events
+        this.addEventListener('textarea-focus', () => {
+            this.isFocused = true;
+        });
+        this.addEventListener('textarea-blur', () => {
+            this.isFocused = false;
+            if (this.validateOnBlur) {
+                this.validationController.validateOnBlurIfEnabled();
+            }
+        });
+        // Clear events
+        this.addEventListener('textarea-clear', (e) => {
+            this.handleControllerClear(e.detail.previousValue);
+        });
+    }
+    /**
+     * Handle input from controller
+     */
+    handleControllerInput(newValue) {
+        // Handle max length
+        if (this.maxLength && newValue.length > this.maxLength) {
+            this.value = newValue.slice(0, this.maxLength);
+        }
+        else {
+            this.value = newValue;
+        }
+        this.characterCount = this.value.length;
+        this.autoResizeIfNeeded();
+        this.dispatchChangeEvent();
+        // Validate if change validation is enabled
+        if (this.validateOnChange) {
+            this.validationController.validateOnChangeIfEnabled(this.value);
+        }
+    }
+    /**
+     * Handle clear from controller
+     */
+    handleControllerClear(previousValue) {
+        this.characterCount = 0;
+        this.dispatchChangeEvent();
+        // Custom clear event for backward compatibility
+        this.dispatchEvent(new CustomEvent('nr-clear', {
+            detail: { value: this.value, previousValue },
+            bubbles: true
+        }));
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this.setupResizeObserver();
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.cleanupResizeObserver();
+    }
+    firstUpdated(changedProperties) {
+        super.firstUpdated(changedProperties);
+        this.updateTextareaValue();
+        this.autoResizeIfNeeded();
+        // Setup resize observer for the textarea element
+        if (this.resizeObserver && this.textareaElement) {
+            this.resizeObserver.observe(this.textareaElement);
+        }
+        // Setup event controllers with DOM elements
+        this.eventController.setupEventListeners();
+    }
+    updated(changedProperties) {
+        super.updated(changedProperties);
+        if (changedProperties.has('value')) {
+            this.characterCount = this.value.length;
+            this.updateTextareaValue();
+            this.autoResizeIfNeeded();
+        }
+        if (changedProperties.has('autoResize')) {
+            this.autoResizeIfNeeded();
+        }
+        // Update validation rules if they changed
+        if (changedProperties.has('rules')) {
+            this.validationController.clearValidation();
+            if (this.rules.length > 0 && this.value) {
+                this.validationController.validate(this.value);
+            }
+        }
+    }
+    setupResizeObserver() {
+        if (typeof ResizeObserver !== 'undefined') {
+            this.resizeObserver = new ResizeObserver((entries) => {
+                for (const entry of entries) {
+                    const { width, height } = entry.contentRect;
+                    this.dispatchResizeEvent(width, height);
+                }
+            });
+        }
+    }
+    cleanupResizeObserver() {
+        if (this.resizeObserver) {
+            this.resizeObserver.disconnect();
+            this.resizeObserver = undefined;
+        }
+    }
+    updateTextareaValue() {
+        if (this.textareaElement && this.textareaElement.value !== this.value) {
+            this.textareaElement.value = this.value;
+        }
+    }
+    autoResizeIfNeeded() {
+        if (!this.autoResize || !this.textareaElement)
+            return;
+        // Reset height to auto to get the natural scroll height
+        this.textareaElement.style.height = 'auto';
+        const scrollHeight = this.textareaElement.scrollHeight;
+        // Apply min/max height constraints
+        let newHeight = scrollHeight;
+        if (this.minHeight && newHeight < this.minHeight) {
+            newHeight = this.minHeight;
+        }
+        if (this.maxHeight && newHeight > this.maxHeight) {
+            newHeight = this.maxHeight;
+        }
+        this.textareaElement.style.height = `${newHeight}px`;
+    }
+    /**
+     * Handle input event (now delegated to event controller via addEventListener)
+     */
+    handleInput(e) {
+        // This method is kept for backward compatibility but actual handling
+        // is now done through the event controller
+        this.eventController.handleInput(e);
+    }
+    /**
+     * Handle focus event (now delegated to event controller)
+     */
+    handleFocus(e) {
+        this.eventController.handleFocus(e);
+        // Dispatch legacy event for backward compatibility
+        this.dispatchEvent(new CustomEvent('nr-focus', {
+            detail: {
+                focused: true,
+                originalEvent: e
+            },
+            bubbles: true
+        }));
+    }
+    /**
+     * Handle blur event (now delegated to event controller)
+     */
+    handleBlur(e) {
+        this.eventController.handleBlur(e);
+        // Dispatch legacy event for backward compatibility
+        this.dispatchEvent(new CustomEvent('nr-blur', {
+            detail: {
+                focused: false,
+                originalEvent: e
+            },
+            bubbles: true
+        }));
+    }
+    /**
+     * Handle clear event (now delegated to event controller)
+     */
+    handleClear() {
+        this.eventController.handleClear();
+    }
+    dispatchChangeEvent() {
+        const detail = {
+            value: this.value,
+            length: this.characterCount,
+            exceedsMaxLength: this.maxLength ? this.characterCount > this.maxLength : false,
+            validation: this.validationResult
+        };
+        this.dispatchEvent(new CustomEvent('nr-textarea-change', {
+            detail,
+            bubbles: true
+        }));
+    }
+    dispatchResizeEvent(width, height) {
+        const detail = {
+            width,
+            height,
+            direction: this.resize
+        };
+        this.dispatchEvent(new CustomEvent('nr-resize', {
+            detail,
+            bubbles: true
+        }));
+    }
+    /**
+     * Focus the textarea with optional configuration
+     */
+    focus(options) {
+        this.eventController.focus();
+        // Handle cursor positioning if needed
+        if ((options === null || options === void 0 ? void 0 : options.cursor) !== undefined || (options === null || options === void 0 ? void 0 : options.select)) {
+            setTimeout(() => {
+                if (!this.textareaElement)
+                    return;
+                if ((options === null || options === void 0 ? void 0 : options.cursor) !== undefined) {
+                    if (typeof options.cursor === 'number') {
+                        this.eventController.setCursorPosition(options.cursor);
+                    }
+                    else if (options.cursor === 'start') {
+                        this.eventController.setCursorPosition(0);
+                    }
+                    else if (options.cursor === 'end') {
+                        this.eventController.setCursorPosition(this.value.length);
+                    }
+                    else if (options.cursor === 'all') {
+                        this.eventController.selectAll();
+                    }
+                }
+                else if (options === null || options === void 0 ? void 0 : options.select) {
+                    this.eventController.selectAll();
+                }
+            });
+        }
+    }
+    /**
+     * Blur the textarea
+     */
+    blur() {
+        this.eventController.blur();
+    }
+    /**
+     * Get validation status
+     */
+    getValidationResult() {
+        return this.validationController.validationResult;
+    }
+    /**
+     * Trigger validation manually (ValidatableComponent interface)
+     */
+    validate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.validationController.validate(this.value);
+            return result.isValid;
+        });
+    }
+    /**
+     * Clear validation state
+     */
+    clearValidation() {
+        this.validationController.clearValidation();
+    }
+    /**
+     * Clear the textarea value
+     */
+    clear() {
+        this.eventController.handleClear();
+    }
+    /**
+     * Add a validation rule (ValidatableComponent interface)
+     */
+    addRule(rule) {
+        this.validationController.addRule(rule);
+    }
+    /**
+     * Remove validation rules matching predicate (ValidatableComponent interface)
+     */
+    removeRule(predicate) {
+        this.validationController.removeRule(predicate);
+    }
+    /**
+     * Clear all validation rules (ValidatableComponent interface)
+     */
+    clearRules() {
+        this.validationController.clearRules();
+    }
+    /**
+     * Get current validation status (ValidatableComponent interface)
+     */
+    getValidationStatus() {
+        var _a;
+        const result = this.validationController.validationResult;
+        return {
+            isValid: (_a = result === null || result === void 0 ? void 0 : result.isValid) !== null && _a !== void 0 ? _a : true,
+            errors: (result === null || result === void 0 ? void 0 : result.level) === 'error' ? result.messages : [],
+            warnings: (result === null || result === void 0 ? void 0 : result.level) === 'warning' ? result.messages : []
+        };
+    }
+    /**
+     * Check if the textarea value is valid
+     */
+    isValid() {
+        return this.validationController.isValid();
+    }
+    // Form integration methods (FormFieldCapable interface)
+    /**
+     * Check validity (HTML form API compatibility)
+     */
+    checkValidity() {
+        return this.validationController.isValid();
+    }
+    /**
+     * Report validity (HTML form API compatibility)
+     */
+    reportValidity() {
+        const isValid = this.validationController.isValid();
+        if (!isValid) {
+            // Trigger validation to show error messages
+            this.validationController.validate(this.value);
+        }
+        return isValid;
+    }
+    /**
+     * Set custom validity message (HTML form API compatibility)
+     */
+    setCustomValidity(message) {
+        if (message) {
+            // Add custom validation rule
+            this.validationController.addRule({
+                validator: () => false,
+                message,
+                level: 'error',
+                blocking: true
+            });
+        }
+        else {
+            // Remove custom validation rules
+            this.validationController.removeRule(rule => rule.message === message);
+        }
+    }
+    /**
+     * Trigger validation manually (enhanced version)
+     */
+    validateTextarea() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.validationController.validate(this.value);
+            return result.isValid;
+        });
+    }
+    /**
+     * Set validation state externally (for form integration)
+     */
+    setValidationStatus(result) {
+        this.validationResult = result;
+        // Update state based on validation result
+        if (result.level === 'error') {
+            this.state = "error" /* TEXTAREA_STATE.Error */;
+        }
+        else if (result.level === 'warning') {
+            this.state = "warning" /* TEXTAREA_STATE.Warning */;
+        }
+        else if (result.isValid) {
+            this.state = "success" /* TEXTAREA_STATE.Success */;
+        }
+        this.requestUpdate();
+    }
+    renderLabel() {
+        return html `
+      <div class="textarea-label">
+        <slot name="label"></slot>
+        ${this.required ? html `<span class="required-indicator">*</span>` : ''}
+      </div>
+    `;
+    }
+    renderTextarea() {
+        return html `
+      <textarea
+        class="textarea-element"
+        .value=${this.value}
+        .disabled=${this.disabled}
+        .readOnly=${this.readonly}
+        .required=${this.required || false}
+        .rows=${this.rows}
+        .cols=${this.cols}
+        .placeholder=${this.placeholder}
+        .autocomplete=${this.autocomplete}
+        .name=${this.name || ''}
+        maxlength=${this.maxLength || ''}
+        style="resize: ${this.resize}"
+        @input=${this.handleInput}
+        @focus=${this.handleFocus}
+        @blur=${this.handleBlur}
+      ></textarea>
+    `;
+    }
+    renderValidationIcon() {
+        if (!this.hasFeedback || !this.validationResult)
+            return '';
+        const iconName = this.validationResult.level === 'error' ? 'error' :
+            this.validationResult.level === 'warning' ? 'warning' : 'check-circle';
+        return html `
+      <nr-icon 
+        class="validation-icon ${this.validationResult.level}"
+        name="${iconName}"
+        size="small"
+      ></nr-icon>
+    `;
+    }
+    renderClearButton() {
+        if (!this.allowClear || !this.value || this.disabled || this.readonly)
+            return '';
+        return html `
+      <button
+        class="clear-button"
+        type="button"
+        @click=${this.handleClear}
+        aria-label="Clear textarea"
+      >
+        <nr-icon name="x" size="small"></nr-icon>
+      </button>
+    `;
+    }
+    renderCharacterCount() {
+        if (!this.showCount)
+            return '';
+        const maxText = this.maxLength ? ` / ${this.maxLength}` : '';
+        const isOverLimit = this.maxLength && this.characterCount > this.maxLength;
+        return html `
+      <div class="character-count ${isOverLimit ? 'over-limit' : ''}">
+        ${this.characterCount}${maxText}
+      </div>
+    `;
+    }
+    renderHelperText() {
+        var _a, _b;
+        const hasHelperSlot = (_a = this.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('slot[name="helper-text"]');
+        const hasHelperSlotContent = hasHelperSlot === null || hasHelperSlot === void 0 ? void 0 : hasHelperSlot.assignedNodes().length;
+        const hasValidationMessages = (_b = this.validationResult) === null || _b === void 0 ? void 0 : _b.messages.length;
+        if (!hasHelperSlotContent && !hasValidationMessages)
+            return '';
+        return html `
+      <div class="helper-text">
+        ${hasValidationMessages ?
+            this.validationResult.messages.map(msg => html `<div class="validation-message ${this.validationResult.level}">${msg}</div>`) :
+            html `<slot name="helper-text"></slot>`}
+      </div>
+    `;
+    }
+    render() {
+        const classes = [
+            'textarea-container',
+            `size-${this.size}`,
+            `variant-${this.variant}`,
+            `state-${this.state}`,
+            this.isFocused ? 'focused' : '',
+            this.disabled ? 'disabled' : '',
+            this.readonly ? 'readonly' : '',
+            this.validationResult ? `validation-${this.validationResult.level}` : ''
+        ].filter(Boolean).join(' ');
+        return html `
+      <div class="${classes}">
+        ${this.renderLabel()}
+        
+        <div class="textarea-wrapper">
+          <div class="addon-before">
+            <slot name="addon-before"></slot>
+          </div>
+          
+          <div class="textarea-input-container">
+            ${this.renderTextarea()}
+            ${this.renderValidationIcon()}
+            ${this.renderClearButton()}
+          </div>
+          
+          <div class="addon-after">
+            <slot name="addon-after"></slot>
+          </div>
+        </div>
+        
+        <div class="textarea-footer">
+          ${this.renderHelperText()}
+          ${this.renderCharacterCount()}
+        </div>
+      </div>
+    `;
+    }
+};
+NrTextareaElement.styles = styles;
+__decorate([
+    query('textarea')
+], NrTextareaElement.prototype, "textareaElement", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], NrTextareaElement.prototype, "disabled", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], NrTextareaElement.prototype, "readonly", void 0);
+__decorate([
+    property({ type: String, reflect: true })
+], NrTextareaElement.prototype, "state", void 0);
+__decorate([
+    property({ type: String })
+], NrTextareaElement.prototype, "value", void 0);
+__decorate([
+    property({ type: String })
+], NrTextareaElement.prototype, "size", void 0);
+__decorate([
+    property({ type: String, reflect: true })
+], NrTextareaElement.prototype, "variant", void 0);
+__decorate([
+    property({ type: String })
+], NrTextareaElement.prototype, "resize", void 0);
+__decorate([
+    property({ type: Number })
+], NrTextareaElement.prototype, "rows", void 0);
+__decorate([
+    property({ type: Number })
+], NrTextareaElement.prototype, "cols", void 0);
+__decorate([
+    property({ type: String })
+], NrTextareaElement.prototype, "placeholder", void 0);
+__decorate([
+    property({ type: String })
+], NrTextareaElement.prototype, "autocomplete", void 0);
+__decorate([
+    property({ type: String })
+], NrTextareaElement.prototype, "name", void 0);
+__decorate([
+    property({ type: Boolean })
+], NrTextareaElement.prototype, "required", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], NrTextareaElement.prototype, "allowClear", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], NrTextareaElement.prototype, "showCount", void 0);
+__decorate([
+    property({ type: Number })
+], NrTextareaElement.prototype, "maxLength", void 0);
+__decorate([
+    property({ type: Number })
+], NrTextareaElement.prototype, "minHeight", void 0);
+__decorate([
+    property({ type: Number })
+], NrTextareaElement.prototype, "maxHeight", void 0);
+__decorate([
+    property({ type: Boolean })
+], NrTextareaElement.prototype, "autoResize", void 0);
+__decorate([
+    property({ type: Array })
+], NrTextareaElement.prototype, "rules", void 0);
+__decorate([
+    property({ type: Boolean, attribute: 'validate-on-change' })
+], NrTextareaElement.prototype, "validateOnChange", void 0);
+__decorate([
+    property({ type: Boolean, attribute: 'validate-on-blur' })
+], NrTextareaElement.prototype, "validateOnBlur", void 0);
+__decorate([
+    property({ type: Boolean, attribute: 'has-feedback' })
+], NrTextareaElement.prototype, "hasFeedback", void 0);
+__decorate([
+    property({ type: String, attribute: 'validation-message' })
+], NrTextareaElement.prototype, "validationMessage", void 0);
+__decorate([
+    state()
+], NrTextareaElement.prototype, "isFocused", void 0);
+__decorate([
+    state()
+], NrTextareaElement.prototype, "validationResult", void 0);
+__decorate([
+    state()
+], NrTextareaElement.prototype, "characterCount", void 0);
+NrTextareaElement = __decorate([
+    customElement('nr-textarea')
+], NrTextareaElement);
+export { NrTextareaElement };
+//# sourceMappingURL=textarea.component.js.map