thaddeus 1.0.26 → 1.0.28

package/src/hooks/useTextInput.js

@@ -0,0 +1,397 @@
+import { isInputModeCharacter } from 'src/components/PromptInput/inputModes.js';
+import { useNotifications } from 'src/context/notifications.js';
+import stripAnsi from 'strip-ansi';
+import { markBackslashReturnUsed } from '../commands/terminalSetup/terminalSetup.js';
+import { addToHistory } from '../history.js';
+import { Cursor, getLastKill, pushToKillRing, recordYank, resetKillAccumulation, resetYankState, updateYankLength, yankPop, } from '../utils/Cursor.js';
+import { env } from '../utils/env.js';
+import { isFullscreenEnvEnabled } from '../utils/fullscreen.js';
+import { isModifierPressed, prewarmModifiers } from '../utils/modifiers.js';
+import { useDoublePress } from './useDoublePress.js';
+const NOOP_HANDLER = () => { };
+function mapInput(input_map) {
+    const map = new Map(input_map);
+    return function (input) {
+        return (map.get(input) ?? NOOP_HANDLER)(input);
+    };
+}
+export function useTextInput({ value: originalValue, onChange, onSubmit, onExit, onExitMessage, onHistoryUp, onHistoryDown, onHistoryReset, onClearInput, mask = '', multiline = false, cursorChar, invert, columns, onImagePaste: _onImagePaste, disableCursorMovementForUpDownKeys = false, disableEscapeDoublePress = false, maxVisibleLines, externalOffset, onOffsetChange, inputFilter, inlineGhostText, dim, }) {
+    // Pre-warm the modifiers module for Apple Terminal (has internal guard, safe to call multiple times)
+    if (env.terminal === 'Apple_Terminal') {
+        prewarmModifiers();
+    }
+    const offset = externalOffset;
+    const setOffset = onOffsetChange;
+    const cursor = Cursor.fromText(originalValue, columns, offset);
+    const { addNotification, removeNotification } = useNotifications();
+    const handleCtrlC = useDoublePress(show => {
+        onExitMessage?.(show, 'Ctrl-C');
+    }, () => onExit?.(), () => {
+        if (originalValue) {
+            onChange('');
+            setOffset(0);
+            onHistoryReset?.();
+        }
+    });
+    // NOTE(keybindings): This escape handler is intentionally NOT migrated to the keybindings system.
+    // It's a text-level double-press escape for clearing input, not an action-level keybinding.
+    // Double-press Esc clears the input and saves to history - this is text editing behavior,
+    // not dialog dismissal, and needs the double-press safety mechanism.
+    const handleEscape = useDoublePress((show) => {
+        if (!originalValue || !show) {
+            return;
+        }
+        addNotification({
+            key: 'escape-again-to-clear',
+            text: 'Esc again to clear',
+            priority: 'immediate',
+            timeoutMs: 1000,
+        });
+    }, () => {
+        // Remove the "Esc again to clear" notification immediately
+        removeNotification('escape-again-to-clear');
+        onClearInput?.();
+        if (originalValue) {
+            // Track double-escape usage for feature discovery
+            // Save to history before clearing
+            if (originalValue.trim() !== '') {
+                addToHistory(originalValue);
+            }
+            onChange('');
+            setOffset(0);
+            onHistoryReset?.();
+        }
+    });
+    const handleEmptyCtrlD = useDoublePress(show => {
+        if (originalValue !== '') {
+            return;
+        }
+        onExitMessage?.(show, 'Ctrl-D');
+    }, () => {
+        if (originalValue !== '') {
+            return;
+        }
+        onExit?.();
+    });
+    function handleCtrlD() {
+        if (cursor.text === '') {
+            // When input is empty, handle double-press
+            handleEmptyCtrlD();
+            return cursor;
+        }
+        // When input is not empty, delete forward like iPython
+        return cursor.del();
+    }
+    function killToLineEnd() {
+        const { cursor: newCursor, killed } = cursor.deleteToLineEnd();
+        pushToKillRing(killed, 'append');
+        return newCursor;
+    }
+    function killToLineStart() {
+        const { cursor: newCursor, killed } = cursor.deleteToLineStart();
+        pushToKillRing(killed, 'prepend');
+        return newCursor;
+    }
+    function killWordBefore() {
+        const { cursor: newCursor, killed } = cursor.deleteWordBefore();
+        pushToKillRing(killed, 'prepend');
+        return newCursor;
+    }
+    function yank() {
+        const text = getLastKill();
+        if (text.length > 0) {
+            const startOffset = cursor.offset;
+            const newCursor = cursor.insert(text);
+            recordYank(startOffset, text.length);
+            return newCursor;
+        }
+        return cursor;
+    }
+    function handleYankPop() {
+        const popResult = yankPop();
+        if (!popResult) {
+            return cursor;
+        }
+        const { text, start, length } = popResult;
+        // Replace the previously yanked text with the new one
+        const before = cursor.text.slice(0, start);
+        const after = cursor.text.slice(start + length);
+        const newText = before + text + after;
+        const newOffset = start + text.length;
+        updateYankLength(text.length);
+        return Cursor.fromText(newText, columns, newOffset);
+    }
+    const handleCtrl = mapInput([
+        ['a', () => cursor.startOfLine()],
+        ['b', () => cursor.left()],
+        ['c', handleCtrlC],
+        ['d', handleCtrlD],
+        ['e', () => cursor.endOfLine()],
+        ['f', () => cursor.right()],
+        ['h', () => cursor.deleteTokenBefore() ?? cursor.backspace()],
+        ['k', killToLineEnd],
+        ['n', () => downOrHistoryDown()],
+        ['p', () => upOrHistoryUp()],
+        ['u', killToLineStart],
+        ['w', killWordBefore],
+        ['y', yank],
+    ]);
+    const handleMeta = mapInput([
+        ['b', () => cursor.prevWord()],
+        ['f', () => cursor.nextWord()],
+        ['d', () => cursor.deleteWordAfter()],
+        ['y', handleYankPop],
+    ]);
+    function handleEnter(key) {
+        if (multiline &&
+            cursor.offset > 0 &&
+            cursor.text[cursor.offset - 1] === '\\') {
+            // Track that the user has used backslash+return
+            markBackslashReturnUsed();
+            return cursor.backspace().insert('\n');
+        }
+        // Meta+Enter or Shift+Enter inserts a newline
+        if (key.meta || key.shift) {
+            return cursor.insert('\n');
+        }
+        // Apple Terminal doesn't support custom Shift+Enter keybindings,
+        // so we use native macOS modifier detection to check if Shift is held
+        if (env.terminal === 'Apple_Terminal' && isModifierPressed('shift')) {
+            return cursor.insert('\n');
+        }
+        onSubmit?.(originalValue);
+    }
+    function upOrHistoryUp() {
+        if (disableCursorMovementForUpDownKeys) {
+            onHistoryUp?.();
+            return cursor;
+        }
+        // Try to move by wrapped lines first
+        const cursorUp = cursor.up();
+        if (!cursorUp.equals(cursor)) {
+            return cursorUp;
+        }
+        // If we can't move by wrapped lines and this is multiline input,
+        // try to move by logical lines (to handle paragraph boundaries)
+        if (multiline) {
+            const cursorUpLogical = cursor.upLogicalLine();
+            if (!cursorUpLogical.equals(cursor)) {
+                return cursorUpLogical;
+            }
+        }
+        // Can't move up at all - trigger history navigation
+        onHistoryUp?.();
+        return cursor;
+    }
+    function downOrHistoryDown() {
+        if (disableCursorMovementForUpDownKeys) {
+            onHistoryDown?.();
+            return cursor;
+        }
+        // Try to move by wrapped lines first
+        const cursorDown = cursor.down();
+        if (!cursorDown.equals(cursor)) {
+            return cursorDown;
+        }
+        // If we can't move by wrapped lines and this is multiline input,
+        // try to move by logical lines (to handle paragraph boundaries)
+        if (multiline) {
+            const cursorDownLogical = cursor.downLogicalLine();
+            if (!cursorDownLogical.equals(cursor)) {
+                return cursorDownLogical;
+            }
+        }
+        // Can't move down at all - trigger history navigation
+        onHistoryDown?.();
+        return cursor;
+    }
+    function mapKey(key) {
+        switch (true) {
+            case key.escape:
+                return () => {
+                    // Skip when a keybinding context (e.g. Autocomplete) owns escape.
+                    // useKeybindings can't shield us via stopImmediatePropagation —
+                    // BaseTextInput's useInput registers first (child effects fire
+                    // before parent effects), so this handler has already run by the
+                    // time the keybinding's handler stops propagation.
+                    if (disableEscapeDoublePress)
+                        return cursor;
+                    handleEscape();
+                    // Return the current cursor unchanged - handleEscape manages state internally
+                    return cursor;
+                };
+            case key.leftArrow && (key.ctrl || key.meta || key.fn):
+                return () => cursor.prevWord();
+            case key.rightArrow && (key.ctrl || key.meta || key.fn):
+                return () => cursor.nextWord();
+            case key.backspace:
+                return key.meta || key.ctrl
+                    ? killWordBefore
+                    : () => cursor.deleteTokenBefore() ?? cursor.backspace();
+            case key.delete:
+                return key.meta ? killToLineEnd : () => cursor.del();
+            case key.ctrl:
+                return handleCtrl;
+            case key.home:
+                return () => cursor.startOfLine();
+            case key.end:
+                return () => cursor.endOfLine();
+            case key.pageDown:
+                // In fullscreen mode, PgUp/PgDn scroll the message viewport instead
+                // of moving the cursor — no-op here, ScrollKeybindingHandler handles it.
+                if (isFullscreenEnvEnabled()) {
+                    return NOOP_HANDLER;
+                }
+                return () => cursor.endOfLine();
+            case key.pageUp:
+                if (isFullscreenEnvEnabled()) {
+                    return NOOP_HANDLER;
+                }
+                return () => cursor.startOfLine();
+            case key.wheelUp:
+            case key.wheelDown:
+                // Mouse wheel events only exist when fullscreen mouse tracking is on.
+                // ScrollKeybindingHandler handles them; no-op here to avoid inserting
+                // the raw SGR sequence as text.
+                return NOOP_HANDLER;
+            case key.return:
+                // Must come before key.meta so Option+Return inserts newline
+                return () => handleEnter(key);
+            case key.meta:
+                return handleMeta;
+            case key.tab:
+                return () => cursor;
+            case key.upArrow && !key.shift:
+                return upOrHistoryUp;
+            case key.downArrow && !key.shift:
+                return downOrHistoryDown;
+            case key.leftArrow:
+                return () => cursor.left();
+            case key.rightArrow:
+                return () => cursor.right();
+            default: {
+                return function (input) {
+                    switch (true) {
+                        // Home key
+                        case input === '\x1b[H' || input === '\x1b[1~':
+                            return cursor.startOfLine();
+                        // End key
+                        case input === '\x1b[F' || input === '\x1b[4~':
+                            return cursor.endOfLine();
+                        default: {
+                            // Trailing \r after text is SSH-coalesced Enter ("o\r") —
+                            // strip it so the Enter isn't inserted as content. Lone \r
+                            // here is Alt+Enter leaking through (META_KEY_CODE_RE doesn't
+                            // match \x1b\r) — leave it for the \r→\n below. Embedded \r
+                            // is multi-line paste from a terminal without bracketed
+                            // paste — convert to \n. Backslash+\r is a stale VS Code
+                            // Shift+Enter binding (pre-#8991 /terminal-setup wrote
+                            // args.text "\\\r\n" to keybindings.json); keep the \r so
+                            // it becomes \n below (anthropics/claude-code#31316).
+                            const text = stripAnsi(input)
+                                // eslint-disable-next-line custom-rules/no-lookbehind-regex -- .replace(re, str) on 1-2 char keystrokes: no-match returns same string (Object.is), regex never runs
+                                .replace(/(?<=[^\\\r\n])\r$/, '')
+                                .replace(/\r/g, '\n');
+                            if (cursor.isAtStart() && isInputModeCharacter(input)) {
+                                return cursor.insert(text).left();
+                            }
+                            return cursor.insert(text);
+                        }
+                    }
+                };
+            }
+        }
+    }
+    // Check if this is a kill command (Ctrl+K, Ctrl+U, Ctrl+W, or Meta+Backspace/Delete)
+    function isKillKey(key, input) {
+        if (key.ctrl && (input === 'k' || input === 'u' || input === 'w')) {
+            return true;
+        }
+        if (key.meta && (key.backspace || key.delete)) {
+            return true;
+        }
+        return false;
+    }
+    // Check if this is a yank command (Ctrl+Y or Alt+Y)
+    function isYankKey(key, input) {
+        return (key.ctrl || key.meta) && input === 'y';
+    }
+    function onInput(input, key) {
+        // Note: Image paste shortcut (chat:imagePaste) is handled via useKeybindings in PromptInput
+        // Apply filter if provided
+        const filteredInput = inputFilter ? inputFilter(input, key) : input;
+        // If the input was filtered out, do nothing
+        if (filteredInput === '' && input !== '') {
+            return;
+        }
+        // Fix Issue #1853: Filter DEL characters that interfere with backspace in SSH/tmux
+        // In SSH/tmux environments, backspace generates both key events and raw DEL chars
+        if (!key.backspace && !key.delete && input.includes('\x7f')) {
+            const delCount = (input.match(/\x7f/g) || []).length;
+            // Apply all DEL characters as backspace operations synchronously
+            // Try to delete tokens first, fall back to character backspace
+            let currentCursor = cursor;
+            for (let i = 0; i < delCount; i++) {
+                currentCursor =
+                    currentCursor.deleteTokenBefore() ?? currentCursor.backspace();
+            }
+            // Update state once with the final result
+            if (!cursor.equals(currentCursor)) {
+                if (cursor.text !== currentCursor.text) {
+                    onChange(currentCursor.text);
+                }
+                setOffset(currentCursor.offset);
+            }
+            resetKillAccumulation();
+            resetYankState();
+            return;
+        }
+        // Reset kill accumulation for non-kill keys
+        if (!isKillKey(key, filteredInput)) {
+            resetKillAccumulation();
+        }
+        // Reset yank state for non-yank keys (breaks yank-pop chain)
+        if (!isYankKey(key, filteredInput)) {
+            resetYankState();
+        }
+        const nextCursor = mapKey(key)(filteredInput);
+        if (nextCursor) {
+            if (!cursor.equals(nextCursor)) {
+                if (cursor.text !== nextCursor.text) {
+                    onChange(nextCursor.text);
+                }
+                setOffset(nextCursor.offset);
+            }
+            // SSH-coalesced Enter: on slow links, "o" + Enter can arrive as one
+            // chunk "o\r". parseKeypress only matches s === '\r', so it hit the
+            // default handler above (which stripped the trailing \r). Text with
+            // exactly one trailing \r is coalesced Enter; lone \r is Alt+Enter
+            // (newline); embedded \r is multi-line paste.
+            if (filteredInput.length > 1 &&
+                filteredInput.endsWith('\r') &&
+                !filteredInput.slice(0, -1).includes('\r') &&
+                // Backslash+CR is a stale VS Code Shift+Enter binding, not
+                // coalesced Enter. See default handler above.
+                filteredInput[filteredInput.length - 2] !== '\\') {
+                onSubmit?.(nextCursor.text);
+            }
+        }
+    }
+    // Prepare ghost text for rendering - validate insertPosition matches current
+    // cursor offset to prevent stale ghost text from a previous keystroke causing
+    // a one-frame jitter (ghost text state is updated via useEffect after render)
+    const ghostTextForRender = inlineGhostText && dim && inlineGhostText.insertPosition === offset
+        ? { text: inlineGhostText.text, dim }
+        : undefined;
+    const cursorPos = cursor.getPosition();
+    return {
+        onInput,
+        renderedValue: cursor.render(cursorChar, mask, invert, ghostTextForRender, maxVisibleLines),
+        offset,
+        setOffset,
+        cursorLine: cursorPos.line - cursor.getViewportStartLine(maxVisibleLines),
+        cursorColumn: cursorPos.column,
+        viewportCharOffset: cursor.getViewportCharOffset(maxVisibleLines),
+        viewportCharEnd: cursor.getViewportCharEnd(maxVisibleLines),
+    };
+}

package/src/hooks/useThaddeusHintRecommendation.js

@@ -0,0 +1,117 @@
+import { c as _c } from "react/compiler-runtime";
+/**
+ * Surfaces plugin-install prompts driven by `<thaddeus-hint />` tags
+ * that CLIs/SDKs emit to stderr. See docs/thaddeus-hints.md.
+ *
+ * Show-once semantics: each plugin is prompted for at most once ever,
+ * recorded in config regardless of yes/no. The pre-store gate in
+ * maybeRecordPluginHint already dropped installed/shown/capped hints, so
+ * anything that reaches this hook is worth resolving.
+ */
+import * as React from 'react';
+import { useNotifications } from '../context/notifications.js';
+import { logEvent } from '../services/analytics/index.js';
+import { clearPendingHint, getPendingHintSnapshot, markShownThisSession, subscribeToPendingHint } from '../utils/thaddeusHints.js';
+import { logForDebugging } from '../utils/debug.js';
+import { disableHintRecommendations, markHintPluginShown, resolvePluginHint } from '../utils/plugins/hintRecommendation.js';
+import { installPluginFromMarketplace } from '../utils/plugins/pluginInstallationHelpers.js';
+import { installPluginAndNotify, usePluginRecommendationBase } from './usePluginRecommendationBase.js';
+export function useThaddeusHintRecommendation() {
+    const $ = _c(11);
+    const pendingHint = React.useSyncExternalStore(subscribeToPendingHint, getPendingHintSnapshot);
+    const { addNotification } = useNotifications();
+    const { recommendation, clearRecommendation, tryResolve } = usePluginRecommendationBase();
+    let t0;
+    let t1;
+    if ($[0] !== pendingHint || $[1] !== tryResolve) {
+        t0 = () => {
+            if (!pendingHint) {
+                return;
+            }
+            tryResolve(async () => {
+                const resolved = await resolvePluginHint(pendingHint);
+                if (resolved) {
+                    logForDebugging(`[useThaddeusHintRecommendation] surfacing ${resolved.pluginId} from ${resolved.sourceCommand}`);
+                    markShownThisSession();
+                }
+                if (getPendingHintSnapshot() === pendingHint) {
+                    clearPendingHint();
+                }
+                return resolved;
+            });
+        };
+        t1 = [pendingHint, tryResolve];
+        $[0] = pendingHint;
+        $[1] = tryResolve;
+        $[2] = t0;
+        $[3] = t1;
+    }
+    else {
+        t0 = $[2];
+        t1 = $[3];
+    }
+    React.useEffect(t0, t1);
+    let t2;
+    if ($[4] !== addNotification || $[5] !== clearRecommendation || $[6] !== recommendation) {
+        t2 = response => {
+            if (!recommendation) {
+                return;
+            }
+            markHintPluginShown(recommendation.pluginId);
+            logEvent("thaddeus_plugin_hint_response", {
+                _PROTO_plugin_name: recommendation.pluginName,
+                _PROTO_marketplace_name: recommendation.marketplaceName,
+                response: response
+            });
+            bb15: switch (response) {
+                case "yes":
+                    {
+                        const { pluginId, pluginName, marketplaceName } = recommendation;
+                        installPluginAndNotify(pluginId, pluginName, "hint-plugin", addNotification, async (pluginData) => {
+                            const result = await installPluginFromMarketplace({
+                                pluginId,
+                                entry: pluginData.entry,
+                                marketplaceName,
+                                scope: "user",
+                                trigger: "hint"
+                            });
+                            if (!result.success) {
+                                throw new Error(result.error);
+                            }
+                        });
+                        break bb15;
+                    }
+                case "disable":
+                    {
+                        disableHintRecommendations();
+                        break bb15;
+                    }
+                case "no":
+            }
+            clearRecommendation();
+        };
+        $[4] = addNotification;
+        $[5] = clearRecommendation;
+        $[6] = recommendation;
+        $[7] = t2;
+    }
+    else {
+        t2 = $[7];
+    }
+    const handleResponse = t2;
+    let t3;
+    if ($[8] !== handleResponse || $[9] !== recommendation) {
+        t3 = {
+            recommendation,
+            handleResponse
+        };
+        $[8] = handleResponse;
+        $[9] = recommendation;
+        $[10] = t3;
+    }
+    else {
+        t3 = $[10];
+    }
+    return t3;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useNotifications","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED","logEvent","clearPendingHint","getPendingHintSnapshot","markShownThisSession","subscribeToPendingHint","logForDebugging","disableHintRecommendations","markHintPluginShown","PluginHintRecommendation","resolvePluginHint","installPluginFromMarketplace","installPluginAndNotify","usePluginRecommendationBase","UseClaudeCodeHintRecommendationResult","recommendation","handleResponse","response","useClaudeCodeHintRecommendation","$","_c","pendingHint","useSyncExternalStore","addNotification","clearRecommendation","tryResolve","t0","t1","resolved","pluginId","sourceCommand","useEffect","t2","_PROTO_plugin_name","pluginName","_PROTO_marketplace_name","marketplaceName","bb15","pluginData","result","entry","scope","trigger","success","Error","error","t3"],"sources":["useClaudeCodeHintRecommendation.tsx"],"sourcesContent":["/**\n * Surfaces plugin-install prompts driven by `<claude-code-hint />` tags\n * that CLIs/SDKs emit to stderr. See docs/claude-code-hints.md.\n *\n * Show-once semantics: each plugin is prompted for at most once ever,\n * recorded in config regardless of yes/no. The pre-store gate in\n * maybeRecordPluginHint already dropped installed/shown/capped hints, so\n * anything that reaches this hook is worth resolving.\n */\n\nimport * as React from 'react'\nimport { useNotifications } from '../context/notifications.js'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED,\n  logEvent,\n} from '../services/analytics/index.js'\nimport {\n  clearPendingHint,\n  getPendingHintSnapshot,\n  markShownThisSession,\n  subscribeToPendingHint,\n} from '../utils/claudeCodeHints.js'\nimport { logForDebugging } from '../utils/debug.js'\nimport {\n  disableHintRecommendations,\n  markHintPluginShown,\n  type PluginHintRecommendation,\n  resolvePluginHint,\n} from '../utils/plugins/hintRecommendation.js'\nimport { installPluginFromMarketplace } from '../utils/plugins/pluginInstallationHelpers.js'\nimport {\n  installPluginAndNotify,\n  usePluginRecommendationBase,\n} from './usePluginRecommendationBase.js'\n\ntype UseClaudeCodeHintRecommendationResult = {\n  recommendation: PluginHintRecommendation | null\n  handleResponse: (response: 'yes' | 'no' | 'disable') => void\n}\n\nexport function useClaudeCodeHintRecommendation(): UseClaudeCodeHintRecommendationResult {\n  const pendingHint = React.useSyncExternalStore(\n    subscribeToPendingHint,\n    getPendingHintSnapshot,\n  )\n  const { addNotification } = useNotifications()\n  const { recommendation, clearRecommendation, tryResolve } =\n    usePluginRecommendationBase<PluginHintRecommendation>()\n\n  React.useEffect(() => {\n    if (!pendingHint) return\n    tryResolve(async () => {\n      const resolved = await resolvePluginHint(pendingHint)\n      if (resolved) {\n        logForDebugging(\n          `[useClaudeCodeHintRecommendation] surfacing ${resolved.pluginId} from ${resolved.sourceCommand}`,\n        )\n        markShownThisSession()\n      }\n      // Drop the slot — but only if it still holds the hint we just\n      // resolved. A newer hint may have overwritten it during the async\n      // lookup; don't clobber that.\n      if (getPendingHintSnapshot() === pendingHint) {\n        clearPendingHint()\n      }\n      return resolved\n    })\n  }, [pendingHint, tryResolve])\n\n  const handleResponse = React.useCallback(\n    (response: 'yes' | 'no' | 'disable') => {\n      if (!recommendation) return\n\n      // Record show-once here, not at resolution-time — the dialog may have\n      // been blocked by a higher-priority focusedInputDialog and never\n      // rendered. Auto-dismiss reaches this via onResponse('no').\n      markHintPluginShown(recommendation.pluginId)\n      logEvent('tengu_plugin_hint_response', {\n        _PROTO_plugin_name:\n          recommendation.pluginName as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED,\n        _PROTO_marketplace_name:\n          recommendation.marketplaceName as AnalyticsMetadata_I_VERIFIED_THIS_IS_PII_TAGGED,\n        response:\n          response as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n      })\n\n      switch (response) {\n        case 'yes': {\n          const { pluginId, pluginName, marketplaceName } = recommendation\n          void installPluginAndNotify(\n            pluginId,\n            pluginName,\n            'hint-plugin',\n            addNotification,\n            async pluginData => {\n              const result = await installPluginFromMarketplace({\n                pluginId,\n                entry: pluginData.entry,\n                marketplaceName,\n                scope: 'user',\n                trigger: 'hint',\n              })\n              if (!result.success) {\n                throw new Error(result.error)\n              }\n            },\n          )\n          break\n        }\n        case 'disable':\n          disableHintRecommendations()\n          break\n        case 'no':\n          break\n      }\n\n      clearRecommendation()\n    },\n    [recommendation, addNotification, clearRecommendation],\n  )\n\n  return { recommendation, handleResponse }\n}\n"],"mappings":";AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,OAAO,KAAKA,KAAK,MAAM,OAAO;AAC9B,SAASC,gBAAgB,QAAQ,6BAA6B;AAC9D,SACE,KAAKC,0DAA0D,EAC/D,KAAKC,+CAA+C,EACpDC,QAAQ,QACH,gCAAgC;AACvC,SACEC,gBAAgB,EAChBC,sBAAsB,EACtBC,oBAAoB,EACpBC,sBAAsB,QACjB,6BAA6B;AACpC,SAASC,eAAe,QAAQ,mBAAmB;AACnD,SACEC,0BAA0B,EAC1BC,mBAAmB,EACnB,KAAKC,wBAAwB,EAC7BC,iBAAiB,QACZ,wCAAwC;AAC/C,SAASC,4BAA4B,QAAQ,+CAA+C;AAC5F,SACEC,sBAAsB,EACtBC,2BAA2B,QACtB,kCAAkC;AAEzC,KAAKC,qCAAqC,GAAG;EAC3CC,cAAc,EAAEN,wBAAwB,GAAG,IAAI;EAC/CO,cAAc,EAAE,CAACC,QAAQ,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,EAAE,GAAG,IAAI;AAC9D,CAAC;AAED,OAAO,SAAAC,gCAAA;EAAA,MAAAC,CAAA,GAAAC,EAAA;EACL,MAAAC,WAAA,GAAoBxB,KAAK,CAAAyB,oBAAqB,CAC5CjB,sBAAsB,EACtBF,sBACF,CAAC;EACD;IAAAoB;EAAA,IAA4BzB,gBAAgB,CAAC,CAAC;EAC9C;IAAAiB,cAAA;IAAAS,mBAAA;IAAAC;EAAA,IACEZ,2BAA2B,CAA2B,CAAC;EAAA,IAAAa,EAAA;EAAA,IAAAC,EAAA;EAAA,IAAAR,CAAA,QAAAE,WAAA,IAAAF,CAAA,QAAAM,UAAA;IAEzCC,EAAA,GAAAA,CAAA;MACd,IAAI,CAACL,WAAW;QAAA;MAAA;MAChBI,UAAU,CAAC;QACT,MAAAG,QAAA,GAAiB,MAAMlB,iBAAiB,CAACW,WAAW,CAAC;QACrD,IAAIO,QAAQ;UACVtB,eAAe,CACb,+CAA+CsB,QAAQ,CAAAC,QAAS,SAASD,QAAQ,CAAAE,aAAc,EACjG,CAAC;UACD1B,oBAAoB,CAAC,CAAC;QAAA;QAKxB,IAAID,sBAAsB,CAAC,CAAC,KAAKkB,WAAW;UAC1CnB,gBAAgB,CAAC,CAAC;QAAA;QACnB,OACM0B,QAAQ;MAAA,CAChB,CAAC;IAAA,CACH;IAAED,EAAA,IAACN,WAAW,EAAEI,UAAU,CAAC;IAAAN,CAAA,MAAAE,WAAA;IAAAF,CAAA,MAAAM,UAAA;IAAAN,CAAA,MAAAO,EAAA;IAAAP,CAAA,MAAAQ,EAAA;EAAA;IAAAD,EAAA,GAAAP,CAAA;IAAAQ,EAAA,GAAAR,CAAA;EAAA;EAlB5BtB,KAAK,CAAAkC,SAAU,CAACL,EAkBf,EAAEC,EAAyB,CAAC;EAAA,IAAAK,EAAA;EAAA,IAAAb,CAAA,QAAAI,eAAA,IAAAJ,CAAA,QAAAK,mBAAA,IAAAL,CAAA,QAAAJ,cAAA;IAG3BiB,EAAA,GAAAf,QAAA;MACE,IAAI,CAACF,cAAc;QAAA;MAAA;MAKnBP,mBAAmB,CAACO,cAAc,CAAAc,QAAS,CAAC;MAC5C5B,QAAQ,CAAC,4BAA4B,EAAE;QAAAgC,kBAAA,EAEnClB,cAAc,CAAAmB,UAAW,IAAIlC,+CAA+C;QAAAmC,uBAAA,EAE5EpB,cAAc,CAAAqB,eAAgB,IAAIpC,+CAA+C;QAAAiB,QAAA,EAEjFA,QAAQ,IAAIlB;MAChB,CAAC,CAAC;MAAAsC,IAAA,EAEF,QAAQpB,QAAQ;QAAA,KACT,KAAK;UAAA;YACR;cAAAY,QAAA;cAAAK,UAAA;cAAAE;YAAA,IAAkDrB,cAAc;YAC3DH,sBAAsB,CACzBiB,QAAQ,EACRK,UAAU,EACV,aAAa,EACbX,eAAe,EACf,MAAAe,UAAA;cACE,MAAAC,MAAA,GAAe,MAAM5B,4BAA4B,CAAC;gBAAAkB,QAAA;gBAAAW,KAAA,EAEzCF,UAAU,CAAAE,KAAM;gBAAAJ,eAAA;gBAAAK,KAAA,EAEhB,MAAM;gBAAAC,OAAA,EACJ;cACX,CAAC,CAAC;cACF,IAAI,CAACH,MAAM,CAAAI,OAAQ;gBACjB,MAAM,IAAIC,KAAK,CAACL,MAAM,CAAAM,KAAM,CAAC;cAAA;YAC9B,CAEL,CAAC;YACD,MAAAR,IAAA;UAAK;QAAA,KAEF,SAAS;UAAA;YACZ9B,0BAA0B,CAAC,CAAC;YAC5B,MAAA8B,IAAA;UAAK;QAAA,KACF,IAAI;MAEX;MAEAb,mBAAmB,CAAC,CAAC;IAAA,CACtB;IAAAL,CAAA,MAAAI,eAAA;IAAAJ,CAAA,MAAAK,mBAAA;IAAAL,CAAA,MAAAJ,cAAA;IAAAI,CAAA,MAAAa,EAAA;EAAA;IAAAA,EAAA,GAAAb,CAAA;EAAA;EAhDH,MAAAH,cAAA,GAAuBgB,EAkDtB;EAAA,IAAAc,EAAA;EAAA,IAAA3B,CAAA,QAAAH,cAAA,IAAAG,CAAA,QAAAJ,cAAA;IAEM+B,EAAA;MAAA/B,cAAA;MAAAC;IAAiC,CAAC;IAAAG,CAAA,MAAAH,cAAA;IAAAG,CAAA,MAAAJ,cAAA;IAAAI,CAAA,OAAA2B,EAAA;EAAA;IAAAA,EAAA,GAAA3B,CAAA;EAAA;EAAA,OAAlC2B,EAAkC;AAAA","ignoreList":[]}

package/src/hooks/useTimeout.js

@@ -0,0 +1,10 @@
+import { useEffect, useState } from 'react';
+export function useTimeout(delay, resetTrigger) {
+    const [isElapsed, setIsElapsed] = useState(false);
+    useEffect(() => {
+        setIsElapsed(false);
+        const timer = setTimeout(setIsElapsed, delay, true);
+        return () => clearTimeout(timer);
+    }, [delay, resetTrigger]);
+    return isElapsed;
+}