@projectcor/maia-components 2.29.0 → 2.30.0

package/lib/hooks/useRecentContexts.js

@@ -0,0 +1,86 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { useCallback, useEffect, useState } from 'react';
+import { getRecentContexts } from '../services/maia/RecentContexts';
+export var useRecentContexts = function useRecentContexts() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    agentId = _ref.agentId,
+    _ref$enabled = _ref.enabled,
+    enabled = _ref$enabled === void 0 ? true : _ref$enabled,
+    _ref$limit = _ref.limit,
+    limit = _ref$limit === void 0 ? 9 : _ref$limit;
+  var _useState = useState([]),
+    _useState2 = _slicedToArray(_useState, 2),
+    contexts = _useState2[0],
+    setContexts = _useState2[1];
+  var _useState3 = useState(false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    loading = _useState4[0],
+    setLoading = _useState4[1];
+  var _useState5 = useState(null),
+    _useState6 = _slicedToArray(_useState5, 2),
+    error = _useState6[0],
+    setError = _useState6[1];
+  var _useState7 = useState(false),
+    _useState8 = _slicedToArray(_useState7, 2),
+    loaded = _useState8[0],
+    setLoaded = _useState8[1];
+  var fetchRecentContexts = useCallback(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var data, message, _t;
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          if (enabled) {
+            _context.next = 1;
+            break;
+          }
+          setContexts([]);
+          setLoading(false);
+          setError(null);
+          setLoaded(false);
+          return _context.abrupt("return");
+        case 1:
+          setLoading(true);
+          setError(null);
+          _context.prev = 2;
+          _context.next = 3;
+          return getRecentContexts({
+            agentId: agentId,
+            limit: limit
+          });
+        case 3:
+          data = _context.sent;
+          setContexts(data);
+          _context.next = 5;
+          break;
+        case 4:
+          _context.prev = 4;
+          _t = _context["catch"](2);
+          message = _t instanceof Error ? _t.message : 'An unknown error occurred';
+          setError(message);
+          setContexts([]);
+          console.error('Error fetching recent contexts:', _t);
+        case 5:
+          _context.prev = 5;
+          setLoading(false);
+          setLoaded(true);
+          return _context.finish(5);
+        case 6:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[2, 4, 5, 6]]);
+  })), [agentId, enabled, limit]);
+  useEffect(function () {
+    fetchRecentContexts();
+  }, [fetchRecentContexts]);
+  return {
+    contexts: contexts,
+    loading: loading,
+    loaded: loaded,
+    error: error,
+    fetchRecentContexts: fetchRecentContexts
+  };
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/hooks/useResize.js

@@ -0,0 +1,29 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { useEffect, useState } from 'react';
+export var useResizeListener = function useResizeListener(ref, dependencies) {
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    showTooltip = _useState2[0],
+    setShowTooltip = _useState2[1];
+  var handleResize = function handleResize() {
+    if (ref.current) {
+      var textWidth = ref.current.scrollWidth;
+      setShowTooltip(textWidth > ref.current.clientWidth);
+    }
+  };
+  useEffect(function () {
+    var resizeListener = function resizeListener() {
+      return handleResize();
+    };
+    handleResize();
+    window.addEventListener('resize', resizeListener);
+    return function () {
+      window.removeEventListener('resize', resizeListener);
+    };
+  }, dependencies);
+  return {
+    showTooltip: showTooltip
+  };
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/hooks/useSlashCommands.js

@@ -0,0 +1,84 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { useCallback, useEffect, useState } from 'react';
+import { getSlashCommands } from '../services/maia/Actions/getSlashCommands';
+import { filterActionsByHourAgentFeatureAccess } from '../constants/maiaHourAgentAccess';
+import { useT } from './useT';
+import { mapBackendLang } from '../utils/mapBackendLang';
+export var useSlashCommands = function useSlashCommands(agentId) {
+  var _useT = useT(),
+    i18n = _useT.i18n;
+  var lang = mapBackendLang(i18n.language);
+  var _useState = useState([]),
+    _useState2 = _slicedToArray(_useState, 2),
+    commands = _useState2[0],
+    setCommands = _useState2[1];
+  var _useState3 = useState(false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    loading = _useState4[0],
+    setLoading = _useState4[1];
+  var _useState5 = useState(null),
+    _useState6 = _slicedToArray(_useState5, 2),
+    error = _useState6[0],
+    setError = _useState6[1];
+  var handleGetSlashCommands = useCallback(/*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(aid) {
+      var response, message, _t;
+      return _regeneratorRuntime.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            setLoading(true);
+            setError(null);
+            _context.prev = 1;
+            _context.next = 2;
+            return getSlashCommands({
+              agentId: aid,
+              lang: lang
+            });
+          case 2:
+            response = _context.sent;
+            if (!(!response || !Array.isArray(response.data))) {
+              _context.next = 3;
+              break;
+            }
+            throw new Error('Invalid response format from server');
+          case 3:
+            setCommands(filterActionsByHourAgentFeatureAccess(response.data));
+            _context.next = 5;
+            break;
+          case 4:
+            _context.prev = 4;
+            _t = _context["catch"](1);
+            message = _t instanceof Error ? _t.message : 'An unknown error occurred';
+            setError(message);
+            console.error('Error fetching slash commands:', _t);
+          case 5:
+            _context.prev = 5;
+            setLoading(false);
+            return _context.finish(5);
+          case 6:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[1, 4, 5, 6]]);
+    }));
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }(), [lang]);
+  useEffect(function () {
+    setCommands([]);
+    setError(null);
+    if (agentId) {
+      handleGetSlashCommands(agentId);
+    }
+  }, [agentId, handleGetSlashCommands]);
+  return {
+    commands: commands,
+    loading: loading,
+    error: error,
+    handleGetSlashCommands: handleGetSlashCommands
+  };
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/hooks/useSmoothStreamText/index.js

@@ -0,0 +1,2 @@
+export { useSmoothStreamText } from './useSmoothStreamText';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJ1c2VTbW9vdGhTdHJlYW1UZXh0Il0sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2hvb2tzL3VzZVNtb290aFN0cmVhbVRleHQvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgdXNlU21vb3RoU3RyZWFtVGV4dCB9IGZyb20gJy4vdXNlU21vb3RoU3RyZWFtVGV4dCdcbiJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsbUJBQW1CLFFBQVEsdUJBQXVCIiwiaWdub3JlTGlzdCI6W119

package/lib/hooks/useSmoothStreamText/useSmoothStreamText.js

@@ -0,0 +1,197 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { useEffect, useRef, useState } from 'react';
+/**
+ * Hook que desacopla la cadencia de llegada del texto (stream SSE) de la
+ * cadencia de renderizado. Usa un timer corto para liberar chars a ritmo
+ * constante hacia el DOM, eliminando los "frenos" que se producen cuando el
+ * backend emite ráfagas de tokens.
+ *
+ * Cuando `enabled` pasa a false (fin de stream), el texto se completa al
+ * instante. Durante el streaming, el buffer se vacía dinámicamente apuntando
+ * al lag configurado.
+ */
+export var useSmoothStreamText = function useSmoothStreamText(targetText, _ref) {
+  var enabled = _ref.enabled,
+    _ref$minCharsPerFrame = _ref.minCharsPerFrame,
+    minCharsPerFrame = _ref$minCharsPerFrame === void 0 ? 1 : _ref$minCharsPerFrame,
+    _ref$maxCharsPerFrame = _ref.maxCharsPerFrame,
+    maxCharsPerFrame = _ref$maxCharsPerFrame === void 0 ? 24 : _ref$maxCharsPerFrame,
+    _ref$targetLagMs = _ref.targetLagMs,
+    targetLagMs = _ref$targetLagMs === void 0 ? 450 : _ref$targetLagMs,
+    _ref$snapToWordBounda = _ref.snapToWordBoundary,
+    snapToWordBoundary = _ref$snapToWordBounda === void 0 ? false : _ref$snapToWordBounda,
+    _ref$adaptToBackendRa = _ref.adaptToBackendRate,
+    adaptToBackendRate = _ref$adaptToBackendRa === void 0 ? true : _ref$adaptToBackendRa,
+    _ref$backendRateFacto = _ref.backendRateFactor,
+    backendRateFactor = _ref$backendRateFacto === void 0 ? 0.95 : _ref$backendRateFacto,
+    _ref$targetBufferMs = _ref.targetBufferMs,
+    targetBufferMs = _ref$targetBufferMs === void 0 ? 600 : _ref$targetBufferMs,
+    _ref$bufferCorrection = _ref.bufferCorrectionMs,
+    bufferCorrectionMs = _ref$bufferCorrection === void 0 ? 500 : _ref$bufferCorrection,
+    _ref$minBufferChars = _ref.minBufferChars,
+    minBufferChars = _ref$minBufferChars === void 0 ? 70 : _ref$minBufferChars,
+    _ref$warmupMs = _ref.warmupMs,
+    warmupMs = _ref$warmupMs === void 0 ? 400 : _ref$warmupMs;
+  var _useState = useState(function () {
+      return enabled ? '' : targetText;
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    displayed = _useState2[0],
+    setDisplayed = _useState2[1];
+  var targetRef = useRef(targetText);
+  var displayedLenRef = useRef(displayed.length);
+  var tickTimerRef = useRef(null);
+  var lastTickRef = useRef(0);
+
+  // Medición de la cadencia del backend: se actualiza cuando cambia targetText.
+  var lastTargetLenRef = useRef(0);
+  var lastTargetUpdateRef = useRef(0);
+  // Estimación EMA de chars/ms producidos por el backend.
+  var backendCharsPerMsRef = useRef(0);
+  // Timestamp del primer chunk recibido (para warmup).
+  var firstChunkAtRef = useRef(0);
+  // Si el warmup ya terminó (una vez true, no vuelve a activarse en este stream).
+  var warmupDoneRef = useRef(false);
+  useEffect(function () {
+    var now = typeof performance !== 'undefined' ? performance.now() : Date.now();
+    var prevTargetLen = lastTargetLenRef.current;
+    var deltaChars = targetText.length - prevTargetLen;
+    var prevTargetAt = lastTargetUpdateRef.current;
+    if (enabled && deltaChars > 0) {
+      if (firstChunkAtRef.current === 0) firstChunkAtRef.current = now;
+    }
+    if (enabled && deltaChars > 0 && prevTargetAt > 0) {
+      var dt = Math.max(1, now - prevTargetAt);
+      var rate = deltaChars / dt;
+      var prevRate = backendCharsPerMsRef.current;
+      // EMA suave (alpha = 0.2) para absorber jitter y seguir la tendencia.
+      backendCharsPerMsRef.current = prevRate === 0 ? rate : prevRate * 0.8 + rate * 0.2;
+    }
+    if (enabled && targetText.length !== prevTargetLen) {
+      lastTargetLenRef.current = targetText.length;
+      lastTargetUpdateRef.current = now;
+    }
+    targetRef.current = targetText;
+    if (!enabled) {
+      if (tickTimerRef.current != null) {
+        window.clearTimeout(tickTimerRef.current);
+        tickTimerRef.current = null;
+      }
+      lastTickRef.current = 0;
+      if (displayedLenRef.current !== targetText.length) {
+        displayedLenRef.current = targetText.length;
+        setDisplayed(targetText);
+      }
+      // Reset de cadencia cuando se apaga para no contaminar el próximo stream.
+      lastTargetLenRef.current = 0;
+      lastTargetUpdateRef.current = 0;
+      backendCharsPerMsRef.current = 0;
+      firstChunkAtRef.current = 0;
+      warmupDoneRef.current = false;
+      return undefined;
+    }
+    if (displayedLenRef.current > targetText.length) {
+      displayedLenRef.current = 0;
+      setDisplayed('');
+    }
+    if (tickTimerRef.current != null) return undefined;
+    var getNow = function getNow() {
+      return typeof performance !== 'undefined' ? performance.now() : Date.now();
+    };
+    var scheduleTick = function scheduleTick(tick) {
+      tickTimerRef.current = window.setTimeout(function () {
+        tick(getNow());
+      }, 16);
+    };
+    var _tick = function tick(tickNow) {
+      var prev = lastTickRef.current;
+      var dt = prev ? Math.min(tickNow - prev, 64) : 16;
+      lastTickRef.current = tickNow;
+      var target = targetRef.current;
+      var currentLen = displayedLenRef.current;
+      var remaining = target.length - currentLen;
+      if (remaining <= 0) {
+        scheduleTick(_tick);
+        return;
+      }
+
+      // Warmup: al comienzo del stream esperamos `warmupMs` desde el primer
+      // chunk antes de empezar a pintar. Esto construye un colchón inicial y
+      // evita arrancar rápido para congelarnos acto seguido si el backend
+      // tarda mucho en emitir el segundo chunk.
+      if (!warmupDoneRef.current) {
+        var firstAt = firstChunkAtRef.current;
+        var waitedMs = firstAt > 0 ? tickNow - firstAt : 0;
+        var warmupComplete = warmupMs <= 0 || waitedMs >= warmupMs || target.length >= minBufferChars * 2;
+        if (!warmupComplete) {
+          scheduleTick(_tick);
+          return;
+        }
+        warmupDoneRef.current = true;
+      }
+
+      // Velocidad base: vaciar el buffer en ~targetLagMs.
+      var charsPerMs = remaining / targetLagMs;
+      var effectiveCharsPerMs = charsPerMs;
+      var backendRate = backendCharsPerMsRef.current;
+      if (adaptToBackendRate && backendRate > 0) {
+        if (typeof targetBufferMs === 'number') {
+          // Control proporcional: mantener el buffer en torno al colchón
+          // objetivo. Si bufferMs < target → frenamos por debajo del backend
+          // para acumular; si bufferMs > target → aceleramos para descargar.
+          // En equilibrio, pintamos al ritmo promedio del backend.
+          //
+          // El colchón objetivo se calcula sobre la tasa **efectiva** que
+          // podemos pintar (capeada por `maxCharsPerFrame` a 60fps), no sobre
+          // la del backend pura. Esto evita el caso patológico de ráfagas:
+          // si el backend tira a 6500 ch/s, el target NO se vuelve 3900 chars
+          // (que el render jamás podría sostener), sino algo razonable que
+          // la animación pueda mantener.
+          //
+          // Piso absoluto: el colchón nunca baja de `minBufferChars` aunque
+          // el backend esté mandando lento al inicio del stream.
+          var renderRateCap = maxCharsPerFrame * 60 / 1000;
+          var effectiveBufferRate = Math.min(backendRate, renderRateCap);
+          var targetBufferChars = Math.max(minBufferChars, targetBufferMs * effectiveBufferRate);
+          var bufferDelta = remaining - targetBufferChars;
+          // Corrección tiene unidades de chars/ms. bufferCorrectionMs controla
+          // qué tan rápido el buffer real converge al objetivo.
+          var correction = bufferDelta / Math.max(1, bufferCorrectionMs);
+          effectiveCharsPerMs = Math.max(0, backendRate + correction);
+          // Acotar por la velocidad de "vaciar en targetLagMs" para que si
+          // de pronto hay un pico gigante de buffer no salgamos disparados.
+          effectiveCharsPerMs = Math.min(effectiveCharsPerMs, charsPerMs);
+        } else {
+          // Modo simple: cap a la tasa del backend * factor.
+          var cap = backendRate * backendRateFactor;
+          effectiveCharsPerMs = Math.min(effectiveCharsPerMs, cap);
+        }
+      }
+      var rawStep = Math.ceil(effectiveCharsPerMs * dt);
+      var step = Math.max(minCharsPerFrame, Math.min(maxCharsPerFrame, rawStep));
+      var nextLen = Math.min(target.length, currentLen + step);
+      if (snapToWordBoundary && nextLen < target.length) {
+        var slice = target.slice(currentLen, nextLen);
+        var lastBoundary = Math.max(slice.lastIndexOf(' '), slice.lastIndexOf('\n'), slice.lastIndexOf('\t'));
+        if (lastBoundary >= 0) {
+          nextLen = currentLen + lastBoundary + 1;
+        }
+      }
+      if (nextLen !== currentLen) {
+        displayedLenRef.current = nextLen;
+        setDisplayed(target.slice(0, nextLen));
+      }
+      scheduleTick(_tick);
+    };
+    scheduleTick(_tick);
+    return function () {
+      if (tickTimerRef.current != null) {
+        window.clearTimeout(tickTimerRef.current);
+        tickTimerRef.current = null;
+      }
+      lastTickRef.current = 0;
+    };
+  }, [targetText, enabled, minCharsPerFrame, maxCharsPerFrame, targetLagMs, snapToWordBoundary, adaptToBackendRate, backendRateFactor, targetBufferMs, bufferCorrectionMs, minBufferChars, warmupMs]);
+  return displayed;
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useEffect","useRef","useState","useSmoothStreamText","targetText","_ref","enabled","_ref$minCharsPerFrame","minCharsPerFrame","_ref$maxCharsPerFrame","maxCharsPerFrame","_ref$targetLagMs","targetLagMs","_ref$snapToWordBounda","snapToWordBoundary","_ref$adaptToBackendRa","adaptToBackendRate","_ref$backendRateFacto","backendRateFactor","_ref$targetBufferMs","targetBufferMs","_ref$bufferCorrection","bufferCorrectionMs","_ref$minBufferChars","minBufferChars","_ref$warmupMs","warmupMs","_useState","_useState2","_slicedToArray","displayed","setDisplayed","targetRef","displayedLenRef","length","tickTimerRef","lastTickRef","lastTargetLenRef","lastTargetUpdateRef","backendCharsPerMsRef","firstChunkAtRef","warmupDoneRef","now","performance","Date","prevTargetLen","current","deltaChars","prevTargetAt","dt","Math","max","rate","prevRate","window","clearTimeout","undefined","getNow","scheduleTick","tick","setTimeout","tickNow","prev","min","target","currentLen","remaining","firstAt","waitedMs","warmupComplete","charsPerMs","effectiveCharsPerMs","backendRate","renderRateCap","effectiveBufferRate","targetBufferChars","bufferDelta","correction","cap","rawStep","ceil","step","nextLen","slice","lastBoundary","lastIndexOf"],"sources":["../../../src/hooks/useSmoothStreamText/useSmoothStreamText.ts"],"sourcesContent":["import { useEffect, useRef, useState } from 'react'\n\ntype UseSmoothStreamTextOptions = {\n  /** Si está deshabilitado, devuelve el target tal cual (sin animación). */\n  enabled: boolean\n  /** Cantidad mínima de chars a liberar por frame cuando hay buffer. */\n  minCharsPerFrame?: number\n  /** Cota superior de chars por frame para evitar saltos grandes. */\n  maxCharsPerFrame?: number\n  /**\n   * Lag objetivo (ms) entre el texto recibido y el mostrado. El hook calcula\n   * dinámicamente el step por frame para vaciar el buffer en ~targetLagMs.\n   * Valores más bajos = se pone al día más rápido (menos \"suave\").\n   */\n  targetLagMs?: number\n  /**\n   * Si está activo, al avanzar se detiene en el último separador de palabra\n   * (espacio, salto de línea, signos de puntuación) para evitar renderizar\n   * markdown \"cortado a la mitad\" y dar una sensación más natural.\n   */\n  snapToWordBoundary?: boolean\n  /**\n   * Si está activo, mide la tasa promedio a la que crece el target (cadencia\n   * del backend en chars/ms) y limita la velocidad de pintado a esa tasa\n   * (multiplicada por `backendRateFactor`). Esto evita el caso típico de\n   * \"pinto rápido hasta vaciar el buffer y después se congela esperando\n   * al próximo chunk del backend\".\n   */\n  adaptToBackendRate?: boolean\n  /**\n   * Factor aplicado a la tasa del backend cuando `adaptToBackendRate` está\n   * activo. Valores < 1 dejan un colchón creciente (más tolerante a pausas);\n   * valores > 1 intentan alcanzar. Default: 0.95.\n   */\n  backendRateFactor?: number\n  /**\n   * Colchón objetivo de buffer expresado en ms (cuánto tiempo de texto queremos\n   * tener siempre adelantado al pintado). Si está definido junto con\n   * `adaptToBackendRate`, se usa un control proporcional: cuando el buffer\n   * baja del objetivo, la velocidad cae por debajo de la del backend para\n   * rellenarlo; cuando lo supera, se acelera para descargarlo. Así la\n   * animación absorbe pausas del backend sin quedarse idle.\n   *\n   * Valor recomendado: 300–600ms según la estabilidad del backend.\n   */\n  targetBufferMs?: number\n  /**\n   * Constante de tiempo (ms) del controlador del buffer. Cuanto más bajo,\n   * más agresivamente corrige desvíos. Default: 500.\n   */\n  bufferCorrectionMs?: number\n  /**\n   * Piso absoluto del colchón en chars: el `targetBufferChars` calculado a\n   * partir de `targetBufferMs × backendRate` nunca baja de este valor. Útil\n   * al comienzo del stream cuando la tasa estimada del backend es baja.\n   * Default: 70.\n   */\n  minBufferChars?: number\n  /**\n   * Warmup: ms que el hook espera \"acumulando\" antes de empezar a pintar,\n   * incluso si ya hay chars en el buffer. Evita el típico \"arranque rápido,\n   * congelamiento\" cuando el primer chunk llega antes que el segundo se\n   * tarda mucho. Si se define como 0, no hay warmup. Default: 400.\n   */\n  warmupMs?: number\n}\n\n/**\n * Hook que desacopla la cadencia de llegada del texto (stream SSE) de la\n * cadencia de renderizado. Usa un timer corto para liberar chars a ritmo\n * constante hacia el DOM, eliminando los \"frenos\" que se producen cuando el\n * backend emite ráfagas de tokens.\n *\n * Cuando `enabled` pasa a false (fin de stream), el texto se completa al\n * instante. Durante el streaming, el buffer se vacía dinámicamente apuntando\n * al lag configurado.\n */\nexport const useSmoothStreamText = (\n  targetText: string,\n  {\n    enabled,\n    minCharsPerFrame = 1,\n    maxCharsPerFrame = 24,\n    targetLagMs = 450,\n    snapToWordBoundary = false,\n    adaptToBackendRate = true,\n    backendRateFactor = 0.95,\n    targetBufferMs = 600,\n    bufferCorrectionMs = 500,\n    minBufferChars = 70,\n    warmupMs = 400,\n  }: UseSmoothStreamTextOptions\n): string => {\n  const [displayed, setDisplayed] = useState<string>(() => (enabled ? '' : targetText))\n\n  const targetRef = useRef(targetText)\n  const displayedLenRef = useRef(displayed.length)\n  const tickTimerRef = useRef<number | null>(null)\n  const lastTickRef = useRef<number>(0)\n\n  // Medición de la cadencia del backend: se actualiza cuando cambia targetText.\n  const lastTargetLenRef = useRef<number>(0)\n  const lastTargetUpdateRef = useRef<number>(0)\n  // Estimación EMA de chars/ms producidos por el backend.\n  const backendCharsPerMsRef = useRef<number>(0)\n  // Timestamp del primer chunk recibido (para warmup).\n  const firstChunkAtRef = useRef<number>(0)\n  // Si el warmup ya terminó (una vez true, no vuelve a activarse en este stream).\n  const warmupDoneRef = useRef<boolean>(false)\n\n  useEffect(() => {\n    const now = typeof performance !== 'undefined' ? performance.now() : Date.now()\n    const prevTargetLen = lastTargetLenRef.current\n    const deltaChars = targetText.length - prevTargetLen\n    const prevTargetAt = lastTargetUpdateRef.current\n\n    if (enabled && deltaChars > 0) {\n      if (firstChunkAtRef.current === 0) firstChunkAtRef.current = now\n    }\n\n    if (enabled && deltaChars > 0 && prevTargetAt > 0) {\n      const dt = Math.max(1, now - prevTargetAt)\n      const rate = deltaChars / dt\n      const prevRate = backendCharsPerMsRef.current\n      // EMA suave (alpha = 0.2) para absorber jitter y seguir la tendencia.\n      backendCharsPerMsRef.current = prevRate === 0 ? rate : prevRate * 0.8 + rate * 0.2\n    }\n    if (enabled && targetText.length !== prevTargetLen) {\n      lastTargetLenRef.current = targetText.length\n      lastTargetUpdateRef.current = now\n    }\n\n    targetRef.current = targetText\n\n    if (!enabled) {\n      if (tickTimerRef.current != null) {\n        window.clearTimeout(tickTimerRef.current)\n        tickTimerRef.current = null\n      }\n      lastTickRef.current = 0\n      if (displayedLenRef.current !== targetText.length) {\n        displayedLenRef.current = targetText.length\n        setDisplayed(targetText)\n      }\n      // Reset de cadencia cuando se apaga para no contaminar el próximo stream.\n      lastTargetLenRef.current = 0\n      lastTargetUpdateRef.current = 0\n      backendCharsPerMsRef.current = 0\n      firstChunkAtRef.current = 0\n      warmupDoneRef.current = false\n      return undefined\n    }\n\n    if (displayedLenRef.current > targetText.length) {\n      displayedLenRef.current = 0\n      setDisplayed('')\n    }\n\n    if (tickTimerRef.current != null) return undefined\n\n    const getNow = () => (typeof performance !== 'undefined' ? performance.now() : Date.now())\n    const scheduleTick = (tick: (tickNow: number) => void) => {\n      tickTimerRef.current = window.setTimeout(() => {\n        tick(getNow())\n      }, 16)\n    }\n\n    const tick = (tickNow: number) => {\n      const prev = lastTickRef.current\n      const dt = prev ? Math.min(tickNow - prev, 64) : 16\n      lastTickRef.current = tickNow\n\n      const target = targetRef.current\n      const currentLen = displayedLenRef.current\n      const remaining = target.length - currentLen\n\n      if (remaining <= 0) {\n        scheduleTick(tick)\n        return\n      }\n\n      // Warmup: al comienzo del stream esperamos `warmupMs` desde el primer\n      // chunk antes de empezar a pintar. Esto construye un colchón inicial y\n      // evita arrancar rápido para congelarnos acto seguido si el backend\n      // tarda mucho en emitir el segundo chunk.\n      if (!warmupDoneRef.current) {\n        const firstAt = firstChunkAtRef.current\n        const waitedMs = firstAt > 0 ? tickNow - firstAt : 0\n        const warmupComplete = warmupMs <= 0 || waitedMs >= warmupMs || target.length >= minBufferChars * 2\n        if (!warmupComplete) {\n          scheduleTick(tick)\n          return\n        }\n        warmupDoneRef.current = true\n      }\n\n      // Velocidad base: vaciar el buffer en ~targetLagMs.\n      const charsPerMs = remaining / targetLagMs\n      let effectiveCharsPerMs = charsPerMs\n\n      const backendRate = backendCharsPerMsRef.current\n\n      if (adaptToBackendRate && backendRate > 0) {\n        if (typeof targetBufferMs === 'number') {\n          // Control proporcional: mantener el buffer en torno al colchón\n          // objetivo. Si bufferMs < target → frenamos por debajo del backend\n          // para acumular; si bufferMs > target → aceleramos para descargar.\n          // En equilibrio, pintamos al ritmo promedio del backend.\n          //\n          // El colchón objetivo se calcula sobre la tasa **efectiva** que\n          // podemos pintar (capeada por `maxCharsPerFrame` a 60fps), no sobre\n          // la del backend pura. Esto evita el caso patológico de ráfagas:\n          // si el backend tira a 6500 ch/s, el target NO se vuelve 3900 chars\n          // (que el render jamás podría sostener), sino algo razonable que\n          // la animación pueda mantener.\n          //\n          // Piso absoluto: el colchón nunca baja de `minBufferChars` aunque\n          // el backend esté mandando lento al inicio del stream.\n          const renderRateCap = (maxCharsPerFrame * 60) / 1000\n          const effectiveBufferRate = Math.min(backendRate, renderRateCap)\n          const targetBufferChars = Math.max(minBufferChars, targetBufferMs * effectiveBufferRate)\n          const bufferDelta = remaining - targetBufferChars\n          // Corrección tiene unidades de chars/ms. bufferCorrectionMs controla\n          // qué tan rápido el buffer real converge al objetivo.\n          const correction = bufferDelta / Math.max(1, bufferCorrectionMs)\n          effectiveCharsPerMs = Math.max(0, backendRate + correction)\n          // Acotar por la velocidad de \"vaciar en targetLagMs\" para que si\n          // de pronto hay un pico gigante de buffer no salgamos disparados.\n          effectiveCharsPerMs = Math.min(effectiveCharsPerMs, charsPerMs)\n        } else {\n          // Modo simple: cap a la tasa del backend * factor.\n          const cap = backendRate * backendRateFactor\n          effectiveCharsPerMs = Math.min(effectiveCharsPerMs, cap)\n        }\n      }\n\n      const rawStep = Math.ceil(effectiveCharsPerMs * dt)\n      const step = Math.max(minCharsPerFrame, Math.min(maxCharsPerFrame, rawStep))\n\n      let nextLen = Math.min(target.length, currentLen + step)\n\n      if (snapToWordBoundary && nextLen < target.length) {\n        const slice = target.slice(currentLen, nextLen)\n        const lastBoundary = Math.max(slice.lastIndexOf(' '), slice.lastIndexOf('\\n'), slice.lastIndexOf('\\t'))\n        if (lastBoundary >= 0) {\n          nextLen = currentLen + lastBoundary + 1\n        }\n      }\n\n      if (nextLen !== currentLen) {\n        displayedLenRef.current = nextLen\n        setDisplayed(target.slice(0, nextLen))\n      }\n\n      scheduleTick(tick)\n    }\n\n    scheduleTick(tick)\n\n    return () => {\n      if (tickTimerRef.current != null) {\n        window.clearTimeout(tickTimerRef.current)\n        tickTimerRef.current = null\n      }\n      lastTickRef.current = 0\n    }\n  }, [\n    targetText,\n    enabled,\n    minCharsPerFrame,\n    maxCharsPerFrame,\n    targetLagMs,\n    snapToWordBoundary,\n    adaptToBackendRate,\n    backendRateFactor,\n    targetBufferMs,\n    bufferCorrectionMs,\n    minBufferChars,\n    warmupMs,\n  ])\n\n  return displayed\n}\n"],"mappings":"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","ignoreList":[]}

package/lib/hooks/useSnackBarManager/useSnackBarManager.js

@@ -0,0 +1,41 @@
+export var useSnackBarManager = function useSnackBarManager() {
+  var handleDispatchSnackbarEvent = function handleDispatchSnackbarEvent(snackbarEvent) {
+    document.dispatchEvent(snackbarEvent);
+  };
+  var handleSnackbarSuccess = function handleSnackbarSuccess(source) {
+    var snackbarEvent = new CustomEvent('snackbar-event', {
+      detail: {
+        show: true,
+        severity: 'success',
+        message: source
+      }
+    });
+    handleDispatchSnackbarEvent(snackbarEvent);
+  };
+  var handleSnackbarError = function handleSnackbarError(source) {
+    var snackbarEvent = new CustomEvent('snackbar-event', {
+      detail: {
+        show: true,
+        severity: 'error',
+        message: source
+      }
+    });
+    handleDispatchSnackbarEvent(snackbarEvent);
+  };
+  var handleSnackbarInfo = function handleSnackbarInfo(source) {
+    var snackbarEvent = new CustomEvent('snackbar-event', {
+      detail: {
+        show: true,
+        severity: 'info',
+        message: source
+      }
+    });
+    handleDispatchSnackbarEvent(snackbarEvent);
+  };
+  return {
+    handleSnackbarSuccess: handleSnackbarSuccess,
+    handleSnackbarError: handleSnackbarError,
+    handleSnackbarInfo: handleSnackbarInfo
+  };
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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