@bastani/atomic 0.8.28-alpha.4 → 0.8.29-alpha.2

package/dist/modes/interactive/interactive-mode.js

@@ -209,6 +209,10 @@ export class InteractiveMode {
         this.extensionInput = undefined;
         this.extensionEditor = undefined;
         this.extensionTerminalInputUnsubscribers = new Set();
+        this.blockingInlineCustomUiDepth = 0;
+        this.deferredInlineCustomUiFocusDepth = 0;
+        this.pendingInlineCustomUiFocus = undefined;
+        this.hostCustomUiStateListeners = new Set();
         // Extension widgets (components rendered above/below the editor)
         this.extensionWidgetsAbove = new Map();
         this.extensionWidgetsBelow = new Map();
@@ -1708,6 +1712,69 @@ export class InteractiveMode {
         }
         this.extensionTerminalInputUnsubscribers.clear();
     }
+    getHostCustomUiState() {
+        const focusDeferred = this.blockingInlineCustomUiDepth > 0 && this.pendingInlineCustomUiFocus !== undefined;
+        return {
+            blockingInlineCustomUiDepth: this.blockingInlineCustomUiDepth,
+            blockingInlineCustomUiActive: this.blockingInlineCustomUiDepth > 0,
+            ...(focusDeferred ? { blockingInlineCustomUiFocusDeferred: true } : {}),
+        };
+    }
+    notifyHostCustomUiStateListeners() {
+        const state = this.getHostCustomUiState();
+        for (const listener of this.hostCustomUiStateListeners) {
+            try {
+                listener(state);
+            }
+            catch {
+                /* ignore observer errors */
+            }
+        }
+    }
+    beginHostInlineCustomUi() {
+        let released = false;
+        this.blockingInlineCustomUiDepth++;
+        this.notifyHostCustomUiStateListeners();
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.blockingInlineCustomUiDepth = Math.max(0, this.blockingInlineCustomUiDepth - 1);
+            this.notifyHostCustomUiStateListeners();
+        };
+    }
+    beginInlineCustomUiFocusDeferral() {
+        let released = false;
+        this.deferredInlineCustomUiFocusDepth++;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.deferredInlineCustomUiFocusDepth = Math.max(0, this.deferredInlineCustomUiFocusDepth - 1);
+            if (this.deferredInlineCustomUiFocusDepth === 0) {
+                this.focusHostInlineCustomUi();
+            }
+        };
+    }
+    shouldDeferInlineCustomUiFocus() {
+        return this.deferredInlineCustomUiFocusDepth > 0;
+    }
+    focusHostInlineCustomUi() {
+        const component = this.pendingInlineCustomUiFocus;
+        if (component === undefined)
+            return false;
+        this.pendingInlineCustomUiFocus = undefined;
+        this.ui.setFocus(component);
+        this.ui.requestRender();
+        this.notifyHostCustomUiStateListeners();
+        return true;
+    }
+    onHostCustomUiStateChange(listener) {
+        this.hostCustomUiStateListeners.add(listener);
+        return () => {
+            this.hostCustomUiStateListeners.delete(listener);
+        };
+    }
     createProjectTrustContext(cwd) {
         const ui = this.createExtensionUIContext();
         return {
@@ -1732,6 +1799,9 @@ export class InteractiveMode {
             input: (title, placeholder, opts) => this.showExtensionInput(title, placeholder, opts),
             notify: (message, type) => this.showExtensionNotify(message, type),
             requestRender: () => this.ui.requestRender(),
+            getHostCustomUiState: () => this.getHostCustomUiState(),
+            onHostCustomUiStateChange: (listener) => this.onHostCustomUiStateChange(listener),
+            focusHostInlineCustomUi: () => this.focusHostInlineCustomUi(),
             onTerminalInput: (handler) => this.addExtensionTerminalInputListener(handler),
             setStatus: (key, text) => this.setExtensionStatus(key, text),
             setWorkingMessage: (message) => {
@@ -1994,17 +2064,20 @@ export class InteractiveMode {
     async showExtensionCustom(factory, options) {
         const savedText = this.editor.getText();
         const isOverlay = options?.overlay ?? false;
-        const restoreEditor = () => {
+        const restoreEditor = (focusEditor) => {
             this.editorContainer.clear();
             this.editorContainer.addChild(this.editor);
             this.editor.setText(savedText);
-            this.ui.setFocus(this.editor);
+            if (focusEditor)
+                this.ui.setFocus(this.editor);
             this.ui.requestRender();
         };
         return new Promise((resolve, reject) => {
             let component;
             let closed = false;
             let mounted = false;
+            let releaseHostInlineCustomUi;
+            let releaseOverlayInlineCustomUiFocusDeferral;
             const disposeComponent = () => {
                 try {
                     component?.dispose?.();
@@ -2013,16 +2086,28 @@ export class InteractiveMode {
                     /* ignore dispose errors */
                 }
             };
+            const releaseHostCustomUi = () => {
+                if (component !== undefined && this.pendingInlineCustomUiFocus === component) {
+                    this.pendingInlineCustomUiFocus = undefined;
+                    this.notifyHostCustomUiStateListeners();
+                }
+                releaseHostInlineCustomUi?.();
+            };
             const cleanupAbortListener = () => {
                 options?.signal?.removeEventListener("abort", abortCustomUi);
             };
             const closeMountedUi = () => {
                 if (!mounted)
                     return;
-                if (isOverlay)
+                if (isOverlay) {
+                    releaseOverlayInlineCustomUiFocusDeferral?.();
+                    releaseOverlayInlineCustomUiFocusDeferral = undefined;
                     this.ui.hideOverlay();
-                else
-                    restoreEditor();
+                }
+                else {
+                    restoreEditor(!this.shouldDeferInlineCustomUiFocus() &&
+                        this.pendingInlineCustomUiFocus !== component);
+                }
             };
             const close = (result) => {
                 if (closed)
@@ -2030,8 +2115,9 @@ export class InteractiveMode {
                 closed = true;
                 cleanupAbortListener();
                 closeMountedUi();
-                resolve(result);
                 disposeComponent();
+                releaseHostCustomUi();
+                resolve(result);
             };
             const rejectAndClose = (reason) => {
                 if (closed)
@@ -2040,6 +2126,7 @@ export class InteractiveMode {
                 cleanupAbortListener();
                 closeMountedUi();
                 disposeComponent();
+                releaseHostCustomUi();
                 reject(reason);
             };
             function abortCustomUi() {
@@ -2049,8 +2136,23 @@ export class InteractiveMode {
                 abortCustomUi();
                 return;
             }
+            releaseHostInlineCustomUi = isOverlay
+                ? undefined
+                : this.beginHostInlineCustomUi();
+            if (options?.signal?.aborted) {
+                abortCustomUi();
+                return;
+            }
             options?.signal?.addEventListener("abort", abortCustomUi, { once: true });
-            Promise.resolve(factory(this.ui, theme, this.keybindings, close))
+            let factoryResult;
+            try {
+                factoryResult = factory(this.ui, theme, this.keybindings, close);
+            }
+            catch (err) {
+                rejectAndClose(err);
+                return;
+            }
+            Promise.resolve(factoryResult)
                 .then((c) => {
                 if (closed) {
                     try {
@@ -2077,13 +2179,56 @@ export class InteractiveMode {
                     };
                     const handle = this.ui.showOverlay(component, resolveOptions());
                     mounted = true;
-                    // Expose handle to caller for visibility control
-                    options?.onHandle?.(handle);
+                    if (options?.deferInlineCustomUiFocus) {
+                        let releaseDeferral = this.beginInlineCustomUiFocusDeferral();
+                        releaseOverlayInlineCustomUiFocusDeferral = () => {
+                            releaseDeferral?.();
+                            releaseDeferral = undefined;
+                        };
+                        const release = () => {
+                            releaseOverlayInlineCustomUiFocusDeferral?.();
+                            releaseOverlayInlineCustomUiFocusDeferral = undefined;
+                        };
+                        const wrappedHandle = {
+                            hide: () => {
+                                release();
+                                handle.hide();
+                            },
+                            setHidden: (hidden) => {
+                                if (hidden)
+                                    release();
+                                handle.setHidden(hidden);
+                                if (!hidden && releaseDeferral === undefined) {
+                                    releaseDeferral = this.beginInlineCustomUiFocusDeferral();
+                                    releaseOverlayInlineCustomUiFocusDeferral = () => {
+                                        releaseDeferral?.();
+                                        releaseDeferral = undefined;
+                                    };
+                                }
+                            },
+                            isHidden: () => handle.isHidden(),
+                            focus: () => handle.focus(),
+                            unfocus: (unfocusOptions) => handle.unfocus(unfocusOptions),
+                            isFocused: () => handle.isFocused(),
+                        };
+                        // Expose handle to caller for visibility control
+                        options?.onHandle?.(wrappedHandle);
+                    }
+                    else {
+                        // Expose handle to caller for visibility control
+                        options?.onHandle?.(handle);
+                    }
                 }
                 else {
                     this.editorContainer.clear();
                     this.editorContainer.addChild(component);
-                    this.ui.setFocus(component);
+                    if (this.shouldDeferInlineCustomUiFocus()) {
+                        this.pendingInlineCustomUiFocus = component;
+                        this.notifyHostCustomUiStateListeners();
+                    }
+                    else {
+                        this.ui.setFocus(component);
+                    }
                     mounted = true;
                     this.ui.requestRender();
                 }
@@ -4349,7 +4494,9 @@ export class InteractiveMode {
         try {
             await this.session.modelRegistry.authStorage.login(providerId, {
                 onAuth: (info) => {
-                    dialog.showAuth(info.url, info.instructions);
+                    dialog.showAuth(info.url, info.instructions, {
+                        showCancelHint: !usesCallbackServer,
+                    });
                     if (usesCallbackServer) {
                         // Show input for manual paste, racing with callback
                         dialog