@dreamtree-org/twreact-ui 1.1.10 → 1.1.12

package/dist/index.esm.js

@@ -15953,9 +15953,19 @@ var SpeechToText = /*#__PURE__*/forwardRef(function (_ref, ref) {
     _ref$autoStart = _ref.autoStart,
     autoStart = _ref$autoStart === void 0 ? false : _ref$autoStart,
     _ref$disabled = _ref.disabled,
-    disabled = _ref$disabled === void 0 ? false : _ref$disabled;
+    disabled = _ref$disabled === void 0 ? false : _ref$disabled,
+    _ref$maxAlternatives = _ref.maxAlternatives,
+    maxAlternatives = _ref$maxAlternatives === void 0 ? 1 : _ref$maxAlternatives,
+    _ref$grammars = _ref.grammars,
+    grammars = _ref$grammars === void 0 ? null : _ref$grammars,
+    _ref$timeout = _ref.timeout,
+    timeout = _ref$timeout === void 0 ? null : _ref$timeout,
+    _ref$clearOnStop = _ref.clearOnStop,
+    clearOnStop = _ref$clearOnStop === void 0 ? false : _ref$clearOnStop;
   var recognitionRef = useRef(null);
   var finalTranscriptRef = useRef("");
+  var timeoutRef = useRef(null);
+  var isMountedRef = useRef(true);
   var _useState = useState(false),
     _useState2 = _slicedToArray(_useState, 2),
     _isListening = _useState2[0],
@@ -15964,34 +15974,48 @@ var SpeechToText = /*#__PURE__*/forwardRef(function (_ref, ref) {
     _useState4 = _slicedToArray(_useState3, 2),
     _isSupported = _useState4[0],
     setIsSupported = _useState4[1];
+  var _useState5 = useState(null),
+    _useState6 = _slicedToArray(_useState5, 2),
+    error = _useState6[0],
+    setError = _useState6[1];
+
+  // Check browser support
   useEffect(function () {
-    if (!("webkitSpeechRecognition" in window) && !("SpeechRecognition" in window)) {
-      setIsSupported(false);
-    } else {
-      setIsSupported(true);
+    var supported = "webkitSpeechRecognition" in window || "SpeechRecognition" in window;
+    setIsSupported(supported);
+    if (!supported) {
+      var err = new Error("Speech recognition not supported in this browser");
+      setError(err);
+      onError(err);
     }
-  }, []);
-  useEffect(function () {
-    if (autoStart && _isSupported) {
-      startListening();
+  }, [onError]);
+
+  // Clear timeout helper
+  var clearInactivityTimeout = useCallback(function () {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
     }
-    return function () {
-      if (recognitionRef.current) {
-        try {
-          recognitionRef.current.onresult = null;
-          recognitionRef.current.onerror = null;
-          recognitionRef.current.onend = null;
-          recognitionRef.current.onstart = null;
-          recognitionRef.current.stop();
-        } catch (e) {}
+  }, []);
+
+  // Reset inactivity timeout
+  var resetInactivityTimeout = useCallback(function () {
+    if (!timeout) return;
+    clearInactivityTimeout();
+    timeoutRef.current = setTimeout(function () {
+      if (recognitionRef.current && _isListening) {
+        stopListening();
       }
-    };
-  }, [autoStart, _isSupported]);
-  function initializeRecognition() {
+    }, timeout);
+  }, [timeout, _isListening]);
+
+  // Initialize recognition
+  var initializeRecognition = useCallback(function () {
     if (recognitionRef.current) return recognitionRef.current;
     var SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
     if (!SpeechRecognition) {
       var err = new Error("SpeechRecognition API not available");
+      setError(err);
       onError(err);
       return null;
     }
@@ -15999,12 +16023,21 @@ var SpeechToText = /*#__PURE__*/forwardRef(function (_ref, ref) {
     recognition.continuous = !!continuous;
     recognition.interimResults = !!interimResults;
     recognition.lang = lang;
+    recognition.maxAlternatives = maxAlternatives;
+    if (grammars) {
+      recognition.grammars = grammars;
+    }
     recognition.onstart = function () {
+      if (!isMountedRef.current) return;
       finalTranscriptRef.current = finalTranscriptRef.current || "";
       setIsListening(true);
+      setError(null);
+      resetInactivityTimeout();
       onStart();
     };
     recognition.onresult = function (event) {
+      if (!isMountedRef.current) return;
+      resetInactivityTimeout();
       var interim = "";
       var finalPart = "";
       for (var i = event.resultIndex; i < event.results.length; i++) {
@@ -16024,21 +16057,48 @@ var SpeechToText = /*#__PURE__*/forwardRef(function (_ref, ref) {
       }
     };
     recognition.onerror = function (event) {
-      var err = event && event.error ? new Error(event.error) : new Error("Speech recognition error");
-      onError(err);
+      if (!isMountedRef.current) return;
+      clearInactivityTimeout();
+      var errorMessage = (event === null || event === void 0 ? void 0 : event.error) || "Speech recognition error";
+      var err = new Error(errorMessage);
+      setError(err);
       setIsListening(false);
+      onError(err);
+
+      // Handle specific errors
+      if (errorMessage === "not-allowed" || errorMessage === "service-not-allowed") {
+        console.warn("Microphone permission denied");
+      } else if (errorMessage === "no-speech") {
+        console.warn("No speech detected");
+      } else if (errorMessage === "aborted") {
+        console.warn("Speech recognition aborted");
+      }
     };
     recognition.onend = function () {
+      if (!isMountedRef.current) return;
+      clearInactivityTimeout();
       setIsListening(false);
+      var finalText = (finalTranscriptRef.current || "").trim();
+      onSpeechComplete(finalText);
       onStop();
-      onSpeechComplete((finalTranscriptRef.current || "").trim());
+      if (clearOnStop) {
+        finalTranscriptRef.current = "";
+      }
     };
     recognitionRef.current = recognition;
     return recognition;
-  }
-  function startListening() {
+  }, [continuous, interimResults, lang, maxAlternatives, grammars, onStart, onSpeaking, onSpeechComplete, onError, onStop, clearOnStop, resetInactivityTimeout, clearInactivityTimeout]);
+
+  // Start listening
+  var startListening = useCallback(function () {
     if (!_isSupported) {
-      onError(new Error("Speech recognition not supported in this browser"));
+      var err = new Error("Speech recognition not supported in this browser");
+      setError(err);
+      onError(err);
+      return;
+    }
+    if (_isListening) {
+      console.warn("Already listening");
       return;
     }
     try {
@@ -16046,24 +16106,68 @@ var SpeechToText = /*#__PURE__*/forwardRef(function (_ref, ref) {
       if (!rec) return;
       rec.start();
     } catch (err) {
+      var _err$message;
+      // Handle "already started" error
+      if ((_err$message = err.message) !== null && _err$message !== void 0 && _err$message.includes("already started")) {
+        console.warn("Recognition already in progress");
+        return;
+      }
+      setError(err);
       onError(err);
     }
-  }
-  function stopListening() {
+  }, [_isSupported, _isListening, initializeRecognition, onError]);
+
+  // Stop listening
+  var stopListening = useCallback(function () {
     if (recognitionRef.current) {
       try {
+        clearInactivityTimeout();
         recognitionRef.current.stop();
-      } catch (e) {}
+      } catch (err) {
+        console.error("Error stopping recognition:", err);
+      }
     }
-  }
-  function toggleListening() {
+  }, [clearInactivityTimeout]);
+
+  // Toggle listening
+  var toggleListening = useCallback(function () {
     if (disabled) return;
     if (_isListening) {
       stopListening();
     } else {
       startListening();
     }
-  }
+  }, [disabled, _isListening, startListening, stopListening]);
+
+  // Auto-start effect
+  useEffect(function () {
+    if (autoStart && _isSupported && !disabled) {
+      startListening();
+    }
+  }, [autoStart, _isSupported, disabled, startListening]);
+
+  // Cleanup on unmount
+  useEffect(function () {
+    isMountedRef.current = true;
+    return function () {
+      isMountedRef.current = false;
+      clearInactivityTimeout();
+      if (recognitionRef.current) {
+        try {
+          recognitionRef.current.onresult = null;
+          recognitionRef.current.onerror = null;
+          recognitionRef.current.onend = null;
+          recognitionRef.current.onstart = null;
+          recognitionRef.current.stop();
+        } catch (err) {
+          console.error("Cleanup error:", err);
+        }
+        recognitionRef.current = null;
+      }
+    };
+  }, [clearInactivityTimeout]);
+
+  // Imperative handle
   useImperativeHandle(ref, function () {
     return {
       start: startListening,
@@ -16080,26 +16184,39 @@ var SpeechToText = /*#__PURE__*/forwardRef(function (_ref, ref) {
       },
       clearTranscript: function clearTranscript() {
         finalTranscriptRef.current = "";
+      },
+      getError: function getError() {
+        return error;
       }
     };
-  }, [_isListening, _isSupported]);
+  }, [_isListening, _isSupported, error, startListening, stopListening, toggleListening]);
+
+  // Custom button renderer
   if (renderButton && typeof renderButton === "function") {
     return renderButton({
       isListening: _isListening,
       isSupported: _isSupported,
+      error: error,
       start: startListening,
       stop: stopListening,
       toggle: toggleListening,
-      disabled: disabled
+      disabled: disabled || !_isSupported
     });
   }
+
+  // Default button
   return /*#__PURE__*/React__default.createElement("button", {
     type: "button",
     "aria-pressed": _isListening,
+    "aria-label": _isListening ? "Stop listening" : "Start listening",
     onClick: toggleListening,
-    disabled: disabled || !_isSupported
-  }, _isListening ? "Stop" : "Start");
+    disabled: disabled || !_isSupported,
+    style: {
+      cursor: disabled || !_isSupported ? "not-allowed" : "pointer"
+    }
+  }, _isListening ? "🎤 Stop" : "🎤 Start");
 });
+SpeechToText.displayName = "SpeechToText";
 
 var TextToSpeech = function TextToSpeech(_ref) {
   var _ref$text = _ref.text,
@@ -22144,10 +22261,11 @@ const trim = (str) => str.trim ?
  * If 'obj' is an Object callback will be called passing
  * the value, key, and complete object for each property.
  *
- * @param {Object|Array} obj The object to iterate
+ * @param {Object|Array<unknown>} obj The object to iterate
  * @param {Function} fn The callback to invoke for each item
  *
- * @param {Boolean} [allOwnKeys = false]
+ * @param {Object} [options]
+ * @param {Boolean} [options.allOwnKeys = false]
  * @returns {any}
  */
 function forEach(obj, fn, {allOwnKeys = false} = {}) {
@@ -22224,7 +22342,7 @@ const isContextDefined = (context) => !isUndefined(context) && context !== _glob
  * Example:
  *
  * ```js
- * var result = merge({foo: 123}, {foo: 456});
+ * const result = merge({foo: 123}, {foo: 456});
  * console.log(result.foo); // outputs 456
  * ```
  *
@@ -22261,15 +22379,26 @@ function merge(/* obj1, obj2, obj3, ... */) {
  * @param {Object} b The object to copy properties from
  * @param {Object} thisArg The object to bind function to
  *
- * @param {Boolean} [allOwnKeys]
+ * @param {Object} [options]
+ * @param {Boolean} [options.allOwnKeys]
  * @returns {Object} The resulting value of object a
  */
 const extend = (a, b, thisArg, {allOwnKeys}= {}) => {
   forEach(b, (val, key) => {
     if (thisArg && isFunction$1(val)) {
-      a[key] = bind(val, thisArg);
+      Object.defineProperty(a, key, {
+        value: bind(val, thisArg),
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
     } else {
-      a[key] = val;
+      Object.defineProperty(a, key, {
+        value: val,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
     }
   }, {allOwnKeys});
   return a;
@@ -22300,7 +22429,12 @@ const stripBOM = (content) => {
  */
 const inherits = (constructor, superConstructor, props, descriptors) => {
   constructor.prototype = Object.create(superConstructor.prototype, descriptors);
-  constructor.prototype.constructor = constructor;
+  Object.defineProperty(constructor.prototype, 'constructor', {
+    value: constructor,
+    writable: true,
+    enumerable: false,
+    configurable: true
+  });
   Object.defineProperty(constructor, 'super', {
     value: superConstructor.prototype
   });
@@ -22673,111 +22807,74 @@ var utils$1 = {
   isIterable
 };
 
-/**
- * Create an Error with the specified message, config, error code, request and response.
- *
- * @param {string} message The error message.
- * @param {string} [code] The error code (for example, 'ECONNABORTED').
- * @param {Object} [config] The config.
- * @param {Object} [request] The request.
- * @param {Object} [response] The response.
- *
- * @returns {Error} The created error.
- */
-function AxiosError$1(message, code, config, request, response) {
-  Error.call(this);
-
-  if (Error.captureStackTrace) {
-    Error.captureStackTrace(this, this.constructor);
-  } else {
-    this.stack = (new Error()).stack;
-  }
-
-  this.message = message;
-  this.name = 'AxiosError';
-  code && (this.code = code);
-  config && (this.config = config);
-  request && (this.request = request);
-  if (response) {
-    this.response = response;
-    this.status = response.status ? response.status : null;
-  }
-}
-
-utils$1.inherits(AxiosError$1, Error, {
-  toJSON: function toJSON() {
-    return {
-      // Standard
-      message: this.message,
-      name: this.name,
-      // Microsoft
-      description: this.description,
-      number: this.number,
-      // Mozilla
-      fileName: this.fileName,
-      lineNumber: this.lineNumber,
-      columnNumber: this.columnNumber,
-      stack: this.stack,
-      // Axios
-      config: utils$1.toJSONObject(this.config),
-      code: this.code,
-      status: this.status
-    };
-  }
-});
-
-const prototype$1 = AxiosError$1.prototype;
-const descriptors = {};
-
-[
-  'ERR_BAD_OPTION_VALUE',
-  'ERR_BAD_OPTION',
-  'ECONNABORTED',
-  'ETIMEDOUT',
-  'ERR_NETWORK',
-  'ERR_FR_TOO_MANY_REDIRECTS',
-  'ERR_DEPRECATED',
-  'ERR_BAD_RESPONSE',
-  'ERR_BAD_REQUEST',
-  'ERR_CANCELED',
-  'ERR_NOT_SUPPORT',
-  'ERR_INVALID_URL'
-// eslint-disable-next-line func-names
-].forEach(code => {
-  descriptors[code] = {value: code};
-});
-
-Object.defineProperties(AxiosError$1, descriptors);
-Object.defineProperty(prototype$1, 'isAxiosError', {value: true});
-
-// eslint-disable-next-line func-names
-AxiosError$1.from = (error, code, config, request, response, customProps) => {
-  const axiosError = Object.create(prototype$1);
-
-  utils$1.toFlatObject(error, axiosError, function filter(obj) {
-    return obj !== Error.prototype;
-  }, prop => {
-    return prop !== 'isAxiosError';
-  });
-
-  const msg = error && error.message ? error.message : 'Error';
-
-  // Prefer explicit code; otherwise copy the low-level error's code (e.g. ECONNREFUSED)
-  const errCode = code == null && error ? error.code : code;
-  AxiosError$1.call(axiosError, msg, errCode, config, request, response);
-
-  // Chain the original error on the standard field; non-enumerable to avoid JSON noise
-  if (error && axiosError.cause == null) {
-    Object.defineProperty(axiosError, 'cause', { value: error, configurable: true });
-  }
-
-  axiosError.name = (error && error.name) || 'Error';
+let AxiosError$1 = class AxiosError extends Error {
+    static from(error, code, config, request, response, customProps) {
+        const axiosError = new AxiosError(error.message, code || error.code, config, request, response);
+        axiosError.cause = error;
+        axiosError.name = error.name;
+        customProps && Object.assign(axiosError, customProps);
+        return axiosError;
+    }
 
-  customProps && Object.assign(axiosError, customProps);
+    /**
+     * Create an Error with the specified message, config, error code, request and response.
+     *
+     * @param {string} message The error message.
+     * @param {string} [code] The error code (for example, 'ECONNABORTED').
+     * @param {Object} [config] The config.
+     * @param {Object} [request] The request.
+     * @param {Object} [response] The response.
+     *
+     * @returns {Error} The created error.
+     */
+    constructor(message, code, config, request, response) {
+        super(message);
+        this.name = 'AxiosError';
+        this.isAxiosError = true;
+        code && (this.code = code);
+        config && (this.config = config);
+        request && (this.request = request);
+        if (response) {
+            this.response = response;
+            this.status = response.status;
+        }
+    }
 
-  return axiosError;
+    toJSON() {
+        return {
+            // Standard
+            message: this.message,
+            name: this.name,
+            // Microsoft
+            description: this.description,
+            number: this.number,
+            // Mozilla
+            fileName: this.fileName,
+            lineNumber: this.lineNumber,
+            columnNumber: this.columnNumber,
+            stack: this.stack,
+            // Axios
+            config: utils$1.toJSONObject(this.config),
+            code: this.code,
+            status: this.status,
+        };
+    }
 };
 
+// This can be changed to static properties as soon as the parser options in .eslint.cjs are updated.
+AxiosError$1.ERR_BAD_OPTION_VALUE = 'ERR_BAD_OPTION_VALUE';
+AxiosError$1.ERR_BAD_OPTION = 'ERR_BAD_OPTION';
+AxiosError$1.ECONNABORTED = 'ECONNABORTED';
+AxiosError$1.ETIMEDOUT = 'ETIMEDOUT';
+AxiosError$1.ERR_NETWORK = 'ERR_NETWORK';
+AxiosError$1.ERR_FR_TOO_MANY_REDIRECTS = 'ERR_FR_TOO_MANY_REDIRECTS';
+AxiosError$1.ERR_DEPRECATED = 'ERR_DEPRECATED';
+AxiosError$1.ERR_BAD_RESPONSE = 'ERR_BAD_RESPONSE';
+AxiosError$1.ERR_BAD_REQUEST = 'ERR_BAD_REQUEST';
+AxiosError$1.ERR_CANCELED = 'ERR_CANCELED';
+AxiosError$1.ERR_NOT_SUPPORT = 'ERR_NOT_SUPPORT';
+AxiosError$1.ERR_INVALID_URL = 'ERR_INVALID_URL';
+
 // eslint-disable-next-line strict
 var httpAdapter = null;
 
@@ -23075,29 +23172,26 @@ function encode(val) {
  * @returns {string} The formatted url
  */
 function buildURL(url, params, options) {
-  /*eslint no-param-reassign:0*/
   if (!params) {
     return url;
   }
-  
+
   const _encode = options && options.encode || encode;
 
-  if (utils$1.isFunction(options)) {
-    options = {
-      serialize: options
-    };
-  } 
+  const _options = utils$1.isFunction(options) ? {
+    serialize: options
+  } : options;
 
-  const serializeFn = options && options.serialize;
+  const serializeFn = _options && _options.serialize;
 
   let serializedParams;
 
   if (serializeFn) {
-    serializedParams = serializeFn(params, options);
+    serializedParams = serializeFn(params, _options);
   } else {
     serializedParams = utils$1.isURLSearchParams(params) ?
       params.toString() :
-      new AxiosURLSearchParams(params, options).toString(_encode);
+      new AxiosURLSearchParams(params, _options).toString(_encode);
   }
 
   if (serializedParams) {
@@ -23122,6 +23216,7 @@ class InterceptorManager {
    *
    * @param {Function} fulfilled The function to handle `then` for a `Promise`
    * @param {Function} rejected The function to handle `reject` for a `Promise`
+   * @param {Object} options The options for the interceptor, synchronous and runWhen
    *
    * @return {Number} An ID used to remove interceptor later
    */
@@ -23899,24 +23994,22 @@ function isCancel$1(value) {
   return !!(value && value.__CANCEL__);
 }
 
-/**
- * A `CanceledError` is an object that is thrown when an operation is canceled.
- *
- * @param {string=} message The message.
- * @param {Object=} config The config.
- * @param {Object=} request The request.
- *
- * @returns {CanceledError} The created error.
- */
-function CanceledError$1(message, config, request) {
-  // eslint-disable-next-line no-eq-null,eqeqeq
-  AxiosError$1.call(this, message == null ? 'canceled' : message, AxiosError$1.ERR_CANCELED, config, request);
-  this.name = 'CanceledError';
-}
-
-utils$1.inherits(CanceledError$1, AxiosError$1, {
-  __CANCEL__: true
-});
+let CanceledError$1 = class CanceledError extends AxiosError$1 {
+  /**
+   * A `CanceledError` is an object that is thrown when an operation is canceled.
+   *
+   * @param {string=} message The message.
+   * @param {Object=} config The config.
+   * @param {Object=} request The request.
+   *
+   * @returns {CanceledError} The created error.
+   */
+  constructor(message, config, request) {
+    super(message == null ? 'canceled' : message, AxiosError$1.ERR_CANCELED, config, request);
+    this.name = 'CanceledError';
+    this.__CANCEL__ = true;
+  }
+};
 
 /**
  * Resolve or reject a Promise based on response status.
@@ -24210,7 +24303,7 @@ function mergeConfig$1(config1, config2) {
 
   function getMergedValue(target, source, prop, caseless) {
     if (utils$1.isPlainObject(target) && utils$1.isPlainObject(source)) {
-      return utils$1.merge.call({caseless}, target, source);
+      return utils$1.merge.call({ caseless }, target, source);
     } else if (utils$1.isPlainObject(source)) {
       return utils$1.merge({}, source);
     } else if (utils$1.isArray(source)) {
@@ -24219,7 +24312,6 @@ function mergeConfig$1(config1, config2) {
     return source;
   }
 
-  // eslint-disable-next-line consistent-return
   function mergeDeepProperties(a, b, prop, caseless) {
     if (!utils$1.isUndefined(b)) {
       return getMergedValue(a, b, prop, caseless);
@@ -24285,7 +24377,7 @@ function mergeConfig$1(config1, config2) {
     headers: (a, b, prop) => mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true)
   };
 
-  utils$1.forEach(Object.keys({...config1, ...config2}), function computeConfigValue(prop) {
+  utils$1.forEach(Object.keys({ ...config1, ...config2 }), function computeConfigValue(prop) {
     const merge = mergeMap[prop] || mergeDeepProperties;
     const configValue = merge(config1[prop], config2[prop], prop);
     (utils$1.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
@@ -24555,7 +24647,7 @@ const composeSignals = (signals, timeout) => {
 
     let timer = timeout && setTimeout(() => {
       timer = null;
-      onabort(new AxiosError$1(`timeout ${timeout} of ms exceeded`, AxiosError$1.ETIMEDOUT));
+      onabort(new AxiosError$1(`timeout of ${timeout}ms exceeded`, AxiosError$1.ETIMEDOUT));
     }, timeout);
 
     const unsubscribe = () => {
@@ -25137,7 +25229,7 @@ function dispatchRequest(config) {
   });
 }
 
-const VERSION$1 = "1.13.2";
+const VERSION$1 = "1.13.4";
 
 const validators$1 = {};
 
@@ -25597,7 +25689,7 @@ let CancelToken$1 = class CancelToken {
  *
  *  ```js
  *  function f(x, y, z) {}
- *  var args = [1, 2, 3];
+ *  const args = [1, 2, 3];
  *  f.apply(null, args);
  *  ```
  *