@syncfusion/ej2-inputs 28.2.11 → 29.1.34

package/dist/es6/ej2-inputs.es2015.js

@@ -1,6 +1,7 @@
 import { isNullOrUndefined, createElement, addClass, attributes, removeClass, formatUnit, remove, detach, classList, closest, Component, getValue, setValue, L10n, getUniqueID, Internationalization, EventHandler, Browser, merge, getNumericObject, Property, Event, NotifyPropertyChanges, extend, ChildProperty, setStyleAttribute, SanitizeHtmlHelper, initializeCSPTemplate, Collection, Complex, Base, onIntlChange, select, selectAll, KeyboardEvents, Ajax, append, Animation, compile, rippleEffect, getInstance } from '@syncfusion/ej2-base';
 import { Tooltip, getZindexPartial, createSpinner, showSpinner, hideSpinner, isCollide, Popup } from '@syncfusion/ej2-popups';
 import { SplitButton, Deferred, getModel } from '@syncfusion/ej2-splitbuttons';
+import { Button } from '@syncfusion/ej2-buttons';
 
 /* eslint-disable valid-jsdoc, jsdoc/require-jsdoc, jsdoc/require-returns, jsdoc/require-param */
 const CLASSNAMES = {
@@ -4203,6 +4204,7 @@ __decorate$2([
 ], TooltipData.prototype, "format", void 0);
 const bootstrapTooltipOffset = 6;
 const bootstrap4TooltipOffset = 3;
+const tolerance = 1e-10;
 const classNames = {
     root: 'e-slider',
     rtl: 'e-rtl',
@@ -4363,15 +4365,6 @@ let Slider = class Slider extends Component {
         const decimals = precision || 0;
         return Number(value.toFixed(decimals));
     }
-    fractionalToInteger(value) {
-        value = (this.numberOfDecimals(value) === 0) ? Number(value).toFixed(this.noOfDecimals) : value;
-        let tens = 1;
-        for (let i = 0; i < this.noOfDecimals; i++) {
-            tens *= 10;
-        }
-        value = Number((value * tens).toFixed(0));
-        return value;
-    }
     /**
      * To Initialize the control rendering
      *
@@ -5170,7 +5163,6 @@ let Slider = class Slider extends Component {
     }
     renderScale() {
         const orien = this.orientation === 'Vertical' ? 'v' : 'h';
-        this.noOfDecimals = this.numberOfDecimals(this.step);
         this.ul = this.createElement('ul', {
             className: classNames.scale + ' ' + 'e-' + orien + '-scale ' + classNames.tick + '-' + this.ticks.placement.toLowerCase(),
             attrs: { role: 'presentation', 'aria-hidden': 'true' }
@@ -5191,9 +5183,9 @@ let Slider = class Slider extends Component {
         else if (smallStep <= 0) {
             smallStep = parseFloat(formatUnit(this.step));
         }
-        const min = this.fractionalToInteger(this.min);
-        const max = this.fractionalToInteger(this.max);
-        const steps = this.fractionalToInteger(smallStep);
+        const min = parseFloat(formatUnit(this.min));
+        const max = parseFloat(formatUnit(this.max));
+        const steps = parseFloat(formatUnit(smallStep));
         const bigNum = !isNullOrUndefined(this.customValues) && this.customValues.length > 0 && this.customValues.length - 1;
         const customStep = this.customTickCounter(bigNum);
         const count = !isNullOrUndefined(this.customValues) && this.customValues.length > 0 ?
@@ -5237,20 +5229,24 @@ let Slider = class Slider extends Component {
                 if (this.numberOfDecimals(this.max) === 0 && this.numberOfDecimals(this.min) === 0 &&
                     this.numberOfDecimals(this.step) === 0) {
                     if (orien === 'h') {
-                        islargeTick = ((start - parseFloat(this.min.toString())) % this.ticks.largeStep === 0) ? true : false;
+                        const reminder = (start - parseFloat(this.min.toString())) % this.ticks.largeStep;
+                        islargeTick = (Math.abs(reminder) < tolerance || Math.abs(this.ticks.largeStep - reminder) < tolerance);
                     }
                     else {
-                        islargeTick = (Math.abs(start - parseFloat(this.max.toString())) % this.ticks.largeStep === 0) ? true : false;
+                        const reminder = Math.abs(start - parseFloat(this.max.toString())) % this.ticks.largeStep;
+                        islargeTick = (Math.abs(reminder) < tolerance || Math.abs(this.ticks.largeStep - reminder) < tolerance);
                     }
                 }
                 else {
-                    const largestep = this.fractionalToInteger(this.ticks.largeStep);
-                    const startValue = this.fractionalToInteger(start);
+                    const largestep = this.ticks.largeStep;
+                    const startValue = start;
                     if (orien === 'h') {
-                        islargeTick = ((startValue - min) % largestep === 0) ? true : false;
+                        const reminder = ((startValue - min) % largestep);
+                        islargeTick = Math.abs(reminder) < tolerance || Math.abs(largestep - reminder) < tolerance;
                     }
                     else {
-                        islargeTick = (Math.abs(startValue - parseFloat(max.toString())) % largestep === 0) ? true : false;
+                        const reminder = Math.abs(startValue - parseFloat(max.toString())) % largestep;
+                        islargeTick = Math.abs(reminder) < tolerance || Math.abs(largestep - reminder) < tolerance;
                     }
                 }
             }
@@ -11028,11 +11024,13 @@ let Uploader = class Uploader extends Component {
     }
     getFilesInArray(files) {
         let uploadFiles = [];
-        if (files instanceof Array) {
-            uploadFiles = files;
-        }
-        else {
-            uploadFiles.push(files);
+        if (files) {
+            if (files instanceof Array) {
+                uploadFiles = files;
+            }
+            else {
+                uploadFiles.push(files);
+            }
         }
         return uploadFiles;
     }
@@ -16768,6 +16766,9 @@ let Rating = class Rating extends Component {
     }
     updateResetButton() {
         if (this.allowReset) {
+            if (this.resetElement) {
+                this.resetElement.blur();
+            }
             const isDisabled = (this.value <= this.min) || this.disabled;
             this.resetElement.classList[isDisabled ? 'add' : 'remove'](DISABLED$2);
             attributes(this.resetElement, { 'tabindex': (isDisabled ? '-1' : '0'), 'aria-hidden': isDisabled.toString() });
@@ -18130,5 +18131,631 @@ OtpInput = __decorate$b([
     NotifyPropertyChanges
 ], OtpInput);
 
-export { AsyncSettings, ButtonsProps, ChatMessageRole, ColorPicker, ColorRangeData, ErrorOption, FilesProp, FormValidator, Input, LabelPosition, LimitData, MaskUndo, MaskedTextBox, NumericTextBox, OtpInput, OtpInputStyle, OtpInputType, PrecisionType, Rating, Signature, SignatureBase, Slider, SmartTextArea, TEXTBOX_FOCUS, TextArea, TextBox, TextTransform, TicksData, TooltipData, Uploader, applyMask, bindClearEvent, containerAttributes, createMask, escapeRegExp, getMaskedVal, getVal, maskInput, maskInputBlurHandler, maskInputDropHandler, maskInputFocusHandler, maskInputMouseDownHandler, maskInputMouseUpHandler, mobileRemoveFunction, regex, regularExpressions, setElementValue, setMaskValue, strippedValue, triggerFocus, unstrippedValue, unwireEvents, wireEvents };
+var __decorate$c = (undefined && undefined.__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;
+};
+/**
+ * Configuration settings for the toggle button used in the SpeechToText component.
+ */
+class ButtonSettings extends ChildProperty {
+}
+__decorate$c([
+    Property('')
+], ButtonSettings.prototype, "content", void 0);
+__decorate$c([
+    Property('')
+], ButtonSettings.prototype, "stopContent", void 0);
+__decorate$c([
+    Property('')
+], ButtonSettings.prototype, "iconCss", void 0);
+__decorate$c([
+    Property('')
+], ButtonSettings.prototype, "stopIconCss", void 0);
+__decorate$c([
+    Property('Left')
+], ButtonSettings.prototype, "iconPosition", void 0);
+__decorate$c([
+    Property(false)
+], ButtonSettings.prototype, "isPrimary", void 0);
+/**
+ * Configuration settings for tooltips in the SpeechToText component.
+ * This allows customization of the tooltip content and its positioning.
+ */
+class TooltipSettings extends ChildProperty {
+}
+__decorate$c([
+    Property('Start listening')
+], TooltipSettings.prototype, "content", void 0);
+__decorate$c([
+    Property('Stop listening')
+], TooltipSettings.prototype, "stopContent", void 0);
+__decorate$c([
+    Property('TopCenter')
+], TooltipSettings.prototype, "position", void 0);
+/**
+ * Enum representing the operational states of the SpeechToText component.
+ */
+var SpeechToTextState;
+(function (SpeechToTextState) {
+    /**
+     * Specifies the state where the SpeechToText component is inactive and not processing spoken input.
+     */
+    SpeechToTextState["Inactive"] = "Inactive";
+    /**
+     * Specifies the state where the SpeechToText component is actively listening to spoken input.
+     */
+    SpeechToTextState["Listening"] = "Listening";
+    /**
+     * Specifies the state where the SpeechToText component has stopped processing spoken input.
+     */
+    SpeechToTextState["Stopped"] = "Stopped";
+})(SpeechToTextState || (SpeechToTextState = {}));
+//#endregion
+let SpeechToText = class SpeechToText extends Component {
+    //#endregion
+    //#region Inherited methods
+    /**
+     * Constructor for creating the component
+     *
+     * @param {SpeechToTextModel} options - Specifies the SpeechToTextModel model.
+     * @param {string | HTMLElement} element - Specifies the element to render as component.
+     * @private
+     */
+    constructor(options, element) {
+        super(options, element);
+        this.fullTranscript = '';
+        this.isClicked = false;
+        this.isUserInteracted = false;
+        this.hasStarted = false;
+    }
+    /**
+     * Initialize the event handler
+     *
+     * @private
+     * @returns {void}
+     */
+    preRender() {
+        if (!this.element.id) {
+            this.element.id = getUniqueID('e-' + this.getModuleName());
+        }
+    }
+    getDirective() {
+        return 'EJS-SPEECHTOTEXT';
+    }
+    /**
+     * To get component name.
+     *
+     * @returns {string} - It returns the current module name.
+     * @private
+     */
+    getModuleName() {
+        return 'speech-to-text';
+    }
+    /**
+     * Get the properties to be maintained in the persisted state.
+     *
+     * @private
+     * @returns {string} - It returns the persisted data.
+     */
+    getPersistData() {
+        return this.addOnPersist([]);
+    }
+    render() {
+        this.renderSpeechToText();
+        this.initializeSpeechRecognition();
+        if (!isNullOrUndefined(this.listeningState)) {
+            this.handleStateChange();
+        }
+        this.wireEvents();
+    }
+    //#endregion
+    //#region Private Methods
+    initializeLocale() {
+        this.l10n = new L10n(this.getModuleName(), {
+            abortedError: 'Speech recognition was aborted.',
+            audioCaptureError: 'No microphone detected. Ensure your microphone is connected.',
+            defaultError: 'An unknown error occurred.',
+            networkError: 'Network error occurred. Check your internet connection.',
+            noSpeechError: 'No speech detected. Please speak into the microphone.',
+            notAllowedError: 'Microphone access denied. Allow microphone permissions.',
+            serviceNotAllowedError: 'Speech recognition service is not allowed in this context.',
+            unsupportedBrowserError: 'The browser does not support the SpeechRecognition API.',
+            startAriaLabel: 'Press to start speaking and transcribe your words',
+            stopAriaLabel: 'Press to stop speaking and end transcription',
+            startTooltipText: 'Start listening',
+            stopTooltipText: 'Stop listening'
+        }, this.locale);
+    }
+    renderSpeechToText() {
+        this.initializeLocale();
+        const iconCss = !isNullOrUndefined(this.buttonSettings.iconCss) && this.buttonSettings.iconCss !== '' ? this.buttonSettings.iconCss : 'e-icons e-listen-icon';
+        this.buttonInst = new Button({
+            iconCss: iconCss,
+            isPrimary: this.buttonSettings.isPrimary,
+            cssClass: this.updateButtonCssClass(),
+            disabled: this.disabled,
+            content: this.buttonSettings.content,
+            iconPosition: this.buttonSettings.iconPosition,
+            enableRtl: this.enableRtl
+        });
+        this.buttonInst.appendTo(this.element);
+        this.updateTooltip();
+        this.updateCssClass(this.cssClass, '');
+        this.updateAriaLabel();
+        if (!isNullOrUndefined(this.htmlAttributes)) {
+            this.addHtmlAttributes(this.htmlAttributes);
+        }
+    }
+    updateAriaLabel() {
+        let ariaLabel;
+        if (this.htmlAttributes && this.htmlAttributes['aria-label']) {
+            ariaLabel = this.htmlAttributes['aria-label'];
+        }
+        else {
+            ariaLabel = this.micOn ? this.l10n.getConstant('stopAriaLabel') : this.l10n.getConstant('startAriaLabel');
+        }
+        this.element.setAttribute('aria-label', ariaLabel);
+    }
+    updateCssClass(newClass, oldClass) {
+        if (oldClass) {
+            removeClass([this.element], oldClass.trim().split(' '));
+        }
+        if (newClass) {
+            addClass([this.element], newClass.trim().split(' '));
+        }
+    }
+    updateButtonCssClass() {
+        const content = this.isClicked ? this.buttonSettings.stopContent : this.buttonSettings.content;
+        let cssClass;
+        if (content === '') {
+            cssClass = 'e-round';
+        }
+        if (this.micOn) {
+            cssClass += ' e-listening-state';
+        }
+        return cssClass;
+    }
+    updateTooltip() {
+        if (this.showTooltip) {
+            if (this.tooltipSettings) {
+                if (this.tooltipSettings.content === 'Start listening') {
+                    this.tooltipSettings.content = this.l10n.getConstant('startTooltipText');
+                }
+                if (this.tooltipSettings.stopContent === 'Stop listening') {
+                    this.tooltipSettings.stopContent = this.l10n.getConstant('stopTooltipText');
+                }
+            }
+            this.tooltipInst = new Tooltip({
+                content: this.hasStarted ? this.tooltipSettings.stopContent : this.tooltipSettings.content,
+                position: this.tooltipSettings.position,
+                windowCollision: true,
+                cssClass: this.cssClass ? ('e-speech-to-text-tooltip ' + this.cssClass) : 'e-speech-to-text-tooltip',
+                opensOn: 'Hover',
+                enableRtl: this.enableRtl
+            });
+            this.tooltipInst.appendTo(this.element);
+        }
+        else {
+            if (!isNullOrUndefined(this.tooltipInst)) {
+                this.tooltipInst.destroy();
+                this.tooltipInst = null;
+            }
+        }
+    }
+    handleStateChange() {
+        if (this.disabled) {
+            return;
+        }
+        if (this.listeningState === SpeechToTextState.Listening) {
+            this.micOn = true;
+            this.startSpeechRecognition();
+        }
+        else if (this.listeningState === SpeechToTextState.Inactive || this.listeningState === SpeechToTextState.Stopped) {
+            if (this.micOn) {
+                this.micOn = false;
+                this.stopSpeechRecognition();
+            }
+            else {
+                const prevOnChange = this.isProtectedOnChange;
+                this.isProtectedOnChange = true;
+                this.listeningState = SpeechToTextState.Inactive;
+                this.isProtectedOnChange = prevOnChange;
+            }
+        }
+    }
+    addHtmlAttributes(attrs) {
+        if (attrs) {
+            for (const attr in attrs) {
+                if (Object.prototype.hasOwnProperty.call(attrs, attr)) {
+                    this.element.setAttribute(attr, attrs[attr]);
+                }
+            }
+        }
+    }
+    removeHtmlAttributes(attrs) {
+        if (attrs) {
+            for (const attr in attrs) {
+                if (Object.prototype.hasOwnProperty.call(attrs, attr)) {
+                    this.element.removeAttribute(attr);
+                }
+            }
+        }
+    }
+    wireEvents() {
+        EventHandler.add(this.element, 'click', this.handleButtonClick, this);
+    }
+    unWireEvents() {
+        EventHandler.remove(this.element, 'click', this.handleButtonClick);
+    }
+    handleButtonClick(event) {
+        this.isUserInteracted = true;
+        this.micOn = !this.micOn;
+        if (this.micOn) {
+            this.startSpeechRecognition(event);
+        }
+        else {
+            this.stopSpeechRecognition(event);
+        }
+    }
+    triggerUnSupportedError() {
+        const eventArgs = {
+            error: 'unsupported-browser',
+            errorMessage: this.l10n.getConstant('unsupportedBrowserError')
+        };
+        this.trigger('onError', eventArgs);
+    }
+    initializeSpeechRecognition() {
+        const windowInst = window;
+        const SpeechRecognition = windowInst.SpeechRecognition || windowInst.webkitSpeechRecognition;
+        if (!SpeechRecognition) {
+            this.triggerUnSupportedError();
+            return;
+        }
+        this.recognition = new SpeechRecognition();
+        this.recognition.continuous = true;
+        this.recognition.lang = this.lang;
+        this.recognition.interimResults = this.allowInterimResults;
+        this.recognition.onstart = (event) => {
+            const prevOnChange = this.isProtectedOnChange;
+            this.isProtectedOnChange = true;
+            this.transcript = this.fullTranscript = '';
+            this.isProtectedOnChange = prevOnChange;
+            const eventArgs = {
+                cancel: false,
+                listeningState: SpeechToTextState.Listening,
+                event: event,
+                isInteracted: this.isUserInteracted
+            };
+            this.trigger('onStart', eventArgs, () => {
+                if (!eventArgs.cancel) {
+                    this.handleStartRecognition();
+                }
+                else {
+                    this.recognition.abort();
+                    this.micOn = false;
+                }
+            });
+        };
+        this.recognition.onend = (event) => {
+            if (this.hasStarted) {
+                this.micOn = false;
+                this.handleStopRecognition(event);
+            }
+        };
+        this.recognition.onerror = (event) => {
+            let errorMessage = '';
+            switch (event.error) {
+                case 'not-allowed':
+                    errorMessage = this.l10n.getConstant('notAllowedError');
+                    break;
+                case 'audio-capture':
+                    errorMessage = this.l10n.getConstant('audioCaptureError');
+                    break;
+                case 'network':
+                    errorMessage = this.l10n.getConstant('networkError');
+                    break;
+                case 'no-speech':
+                    errorMessage = this.l10n.getConstant('noSpeechError');
+                    break;
+                case 'aborted':
+                    errorMessage = this.l10n.getConstant('abortedError');
+                    break;
+                case 'service-not-allowed':
+                    errorMessage = this.l10n.getConstant('serviceNotAllowedError');
+                    break;
+                default:
+                    errorMessage = this.l10n.getConstant('defaultError');
+            }
+            const eventArgs = {
+                event: event,
+                error: event.error,
+                errorMessage: errorMessage
+            };
+            this.trigger('onError', eventArgs);
+            this.isUserInteracted = false;
+        };
+        this.recognition.onresult = (event) => {
+            const result = event.results[event.resultIndex];
+            let interimTranscript = '';
+            const prevOnChange = this.isProtectedOnChange;
+            this.isProtectedOnChange = true;
+            if (result.isFinal) {
+                this.fullTranscript += result[0].transcript;
+                this.transcript = this.fullTranscript;
+            }
+            else {
+                interimTranscript += result[0].transcript;
+                this.transcript = this.fullTranscript + interimTranscript;
+            }
+            const eventArgs = {
+                event: event,
+                transcript: this.transcript,
+                isInterimResult: !result.isFinal
+            };
+            this.trigger('transcriptChanged', eventArgs, () => {
+                if (eventArgs.transcript !== this.transcript) {
+                    const prevOnChange = this.isProtectedOnChange;
+                    this.isProtectedOnChange = true;
+                    this.transcript = this.fullTranscript = eventArgs.transcript;
+                    this.isProtectedOnChange = prevOnChange;
+                }
+            });
+            this.isProtectedOnChange = prevOnChange;
+        };
+    }
+    handleStartRecognition() {
+        const prevOnChange = this.isProtectedOnChange;
+        this.isProtectedOnChange = true;
+        this.hasStarted = true;
+        this.listeningState = SpeechToTextState.Listening;
+        if (!isNullOrUndefined(this.tooltipInst)) {
+            this.tooltipInst.content = this.tooltipSettings.stopContent;
+        }
+        this.updateAriaLabel();
+        this.isClicked = true;
+        this.buttonInst.cssClass = this.updateButtonCssClass();
+        this.buttonInst.content = this.buttonSettings.stopContent;
+        const iconCss = !isNullOrUndefined(this.buttonSettings.stopIconCss) && this.buttonSettings.stopIconCss !== '' ? this.buttonSettings.stopIconCss : 'e-icons e-listen-stop';
+        this.buttonInst.iconCss = iconCss;
+        this.isProtectedOnChange = prevOnChange;
+    }
+    triggerUnSupportedStart(event) {
+        const prevOnChange = this.isProtectedOnChange;
+        this.isProtectedOnChange = true;
+        this.transcript = '';
+        this.isProtectedOnChange = prevOnChange;
+        const eventArgs = {
+            cancel: false,
+            listeningState: SpeechToTextState.Listening,
+            event: event,
+            isInteracted: this.isUserInteracted
+        };
+        this.trigger('onStart', eventArgs, () => {
+            if (!eventArgs.cancel) {
+                this.handleStartRecognition();
+            }
+        });
+    }
+    startSpeechRecognition(event) {
+        if (this.hasStarted) {
+            return;
+        }
+        if (this.recognition) {
+            this.recognition.start();
+        }
+        else {
+            this.triggerUnSupportedStart(event);
+        }
+    }
+    stopSpeechRecognition(event) {
+        if (this.recognition) {
+            this.recognition.stop();
+        }
+        else {
+            this.handleStopRecognition(event);
+        }
+    }
+    handleStopRecognition(event) {
+        if (!this.hasStarted) {
+            return;
+        } // Ensure onStop is only processed if needed
+        const prevOnChange = this.isProtectedOnChange;
+        this.isProtectedOnChange = true;
+        this.listeningState = SpeechToTextState.Stopped;
+        if (!isNullOrUndefined(this.tooltipInst)) {
+            this.tooltipInst.content = this.tooltipSettings.content;
+        }
+        this.updateAriaLabel();
+        this.isClicked = false;
+        this.buttonInst.cssClass = this.updateButtonCssClass();
+        this.buttonInst.content = this.buttonSettings.content;
+        const eventArgs = {
+            listeningState: SpeechToTextState.Stopped,
+            event: event,
+            isInteracted: this.isUserInteracted
+        };
+        this.trigger('onStop', eventArgs);
+        this.listeningState = SpeechToTextState.Inactive;
+        const iconCss = !isNullOrUndefined(this.buttonSettings.iconCss) && this.buttonSettings.iconCss !== '' ? this.buttonSettings.iconCss : 'e-icons e-listen-icon';
+        this.buttonInst.iconCss = iconCss;
+        this.hasStarted = false;
+        this.isProtectedOnChange = prevOnChange;
+    }
+    buttonSettingsChanges(oldModel, newModel) {
+        if (oldModel.content !== newModel.content || oldModel.stopContent !== newModel.stopContent) {
+            this.buttonInst.content = this.hasStarted ? this.buttonSettings.stopContent : this.buttonSettings.content;
+            this.buttonInst.cssClass = this.updateButtonCssClass();
+        }
+        if (oldModel.iconCss !== newModel.iconCss || oldModel.stopIconCss !== newModel.stopIconCss) {
+            const iconCss = !isNullOrUndefined(this.buttonSettings.iconCss) && this.buttonSettings.iconCss !== '' ? this.buttonSettings.iconCss : 'e-icons e-listen-icon';
+            const stopIconCss = !isNullOrUndefined(this.buttonSettings.stopIconCss) && this.buttonSettings.stopIconCss !== '' ? this.buttonSettings.stopIconCss : 'e-icons e-listen-stop';
+            this.buttonInst.iconCss = this.hasStarted ? stopIconCss : iconCss;
+        }
+        if (oldModel.iconPosition !== newModel.iconPosition) {
+            this.buttonInst.iconPosition = this.buttonSettings.iconPosition;
+        }
+        if (oldModel.isPrimary !== newModel.isPrimary) {
+            this.buttonInst.isPrimary = this.buttonSettings.isPrimary;
+        }
+    }
+    destroyAndNullify(obj) {
+        if (obj) {
+            obj.destroy();
+            obj = null;
+        }
+    }
+    //#endregion
+    //#region Public Methods
+    /**
+     * Destroy the SpeechToText.
+     *
+     * @returns {void}
+     */
+    destroy() {
+        super.destroy();
+        this.unWireEvents();
+        this.destroyAndNullify(this.buttonInst);
+        this.destroyAndNullify(this.tooltipInst);
+        this.recognition = null;
+        this.micOn = null;
+        this.htmlAttributes = this.tooltipSettings = this.buttonSettings = null;
+        this.element.classList.remove('e-rtl');
+    }
+    /**
+     * Begins the audio capture process by listening to the user's microphone input.
+     * This method initiates the speech-to-text process and continuously updates the `transcript` property with interim and final recognition results.
+     *
+     * @returns {void} No return value.
+     */
+    startListening() {
+        if (!this.disabled && !this.isClicked) {
+            this.isUserInteracted = false;
+            this.micOn = true;
+            this.startSpeechRecognition();
+        }
+    }
+    /**
+     * Stops the audio capture process and finalizes the speech recognition.
+     * This method ends the ongoing speech-to-text operation and completes the recognition process, storing the final transcription.
+     * It is typically called to stop listening when the user is finished speaking.
+     *
+     * @returns {void} No return value.
+     */
+    stopListening() {
+        if (!this.disabled && this.isClicked) {
+            this.isUserInteracted = false;
+            this.micOn = false;
+            this.stopSpeechRecognition();
+        }
+    }
+    /**
+     * Called if any of the property value is changed.
+     *
+     * @param  {SpeechToTextModel} newProp - Specifies new properties
+     * @param  {SpeechToTextModel} oldProp - Specifies old properties
+     * @returns {void}
+     * @private
+     */
+    onPropertyChanged(newProp, oldProp) {
+        for (const prop of Object.keys(newProp)) {
+            switch (prop) {
+                case 'lang':
+                    if (this.recognition) {
+                        this.recognition.lang = this.lang;
+                    }
+                    break;
+                case 'allowInterimResults':
+                    if (this.recognition) {
+                        this.recognition.interimResults = this.allowInterimResults;
+                    }
+                    break;
+                case 'buttonSettings':
+                    this.buttonSettingsChanges(oldProp.buttonSettings, newProp.buttonSettings);
+                    break;
+                case 'cssClass':
+                    this.updateCssClass(newProp.cssClass, oldProp.cssClass);
+                    break;
+                case 'disabled':
+                    this.buttonInst.disabled = this.disabled;
+                    this.handleStateChange();
+                    break;
+                case 'htmlAttributes':
+                    this.removeHtmlAttributes(oldProp.htmlAttributes);
+                    this.addHtmlAttributes(newProp.htmlAttributes);
+                    break;
+                case 'listeningState':
+                    this.handleStateChange();
+                    break;
+                case 'tooltipSettings':
+                case 'showTooltip':
+                    this.updateTooltip();
+                    break;
+                case 'transcript':
+                    this.transcript = this.fullTranscript = newProp.transcript;
+                    break;
+                case 'enableRtl':
+                    this.buttonInst.enableRtl = this.tooltipInst.enableRtl = this.enableRtl;
+                    break;
+                case 'locale':
+                    this.l10n.setLocale(this.locale);
+                    this.updateAriaLabel();
+                    this.updateTooltip();
+                    break;
+            }
+        }
+    }
+};
+__decorate$c([
+    Property('')
+], SpeechToText.prototype, "transcript", void 0);
+__decorate$c([
+    Property('')
+], SpeechToText.prototype, "lang", void 0);
+__decorate$c([
+    Property(true)
+], SpeechToText.prototype, "allowInterimResults", void 0);
+__decorate$c([
+    Property(true)
+], SpeechToText.prototype, "showTooltip", void 0);
+__decorate$c([
+    Property('Inactive')
+], SpeechToText.prototype, "listeningState", void 0);
+__decorate$c([
+    Complex({}, ButtonSettings)
+], SpeechToText.prototype, "buttonSettings", void 0);
+__decorate$c([
+    Complex({}, TooltipSettings)
+], SpeechToText.prototype, "tooltipSettings", void 0);
+__decorate$c([
+    Property(false)
+], SpeechToText.prototype, "disabled", void 0);
+__decorate$c([
+    Property('')
+], SpeechToText.prototype, "cssClass", void 0);
+__decorate$c([
+    Property({})
+], SpeechToText.prototype, "htmlAttributes", void 0);
+__decorate$c([
+    Event()
+], SpeechToText.prototype, "created", void 0);
+__decorate$c([
+    Event()
+], SpeechToText.prototype, "onStart", void 0);
+__decorate$c([
+    Event()
+], SpeechToText.prototype, "onStop", void 0);
+__decorate$c([
+    Event()
+], SpeechToText.prototype, "onError", void 0);
+__decorate$c([
+    Event()
+], SpeechToText.prototype, "transcriptChanged", void 0);
+SpeechToText = __decorate$c([
+    NotifyPropertyChanges
+], SpeechToText);
+
+export { AsyncSettings, ButtonSettings, ButtonsProps, ChatMessageRole, ColorPicker, ColorRangeData, ErrorOption, FilesProp, FormValidator, Input, LabelPosition, LimitData, MaskUndo, MaskedTextBox, NumericTextBox, OtpInput, OtpInputStyle, OtpInputType, PrecisionType, Rating, Signature, SignatureBase, Slider, SmartTextArea, SpeechToText, SpeechToTextState, TEXTBOX_FOCUS, TextArea, TextBox, TextTransform, TicksData, TooltipData, TooltipSettings, Uploader, applyMask, bindClearEvent, containerAttributes, createMask, escapeRegExp, getMaskedVal, getVal, maskInput, maskInputBlurHandler, maskInputDropHandler, maskInputFocusHandler, maskInputMouseDownHandler, maskInputMouseUpHandler, mobileRemoveFunction, regex, regularExpressions, setElementValue, setMaskValue, strippedValue, triggerFocus, unstrippedValue, unwireEvents, wireEvents };
 //# sourceMappingURL=ej2-inputs.es2015.js.map