byterover-cli 3.10.0 → 3.10.1

package/dist/server/infra/process/task-router.js

@@ -54,6 +54,7 @@ export class TaskRouter {
      */
     completedTasks = new Map();
     getAgentForProject;
+    isReviewDisabled;
     lifecycleHooks;
     preDispatchCheck;
     projectRegistry;
@@ -66,6 +67,7 @@ export class TaskRouter {
         this.transport = options.transport;
         this.agentPool = options.agentPool;
         this.getAgentForProject = options.getAgentForProject;
+        this.isReviewDisabled = options.isReviewDisabled;
         this.lifecycleHooks = options.lifecycleHooks ?? [];
         this.preDispatchCheck = options.preDispatchCheck;
         this.projectRegistry = options.projectRegistry;
@@ -328,7 +330,18 @@ export class TaskRouter {
         this.transport.sendTo(clientId, TransportTaskEventNames.CREATED, createdPayload);
         // Broadcast to other clients in the project room (exclude creator to avoid duplicate)
         broadcastToProjectRoom(this.projectRegistry, this.projectRouter, projectPath, TransportTaskEventNames.CREATED, createdPayload, clientId);
-        // ── Await lifecycle hooks ─────────────────────────────────────────────────
+        // ── Snapshot reviewDisabled + await lifecycle hooks ───────────────────────
+        // Snapshot the project's review-disabled flag once at the task-create boundary.
+        // Placed after the synchronous tasks.set/task:created so callers that don't
+        // await the create handler still see the task in this.tasks immediately.
+        // The value is stamped onto TaskInfo (for CurateLogHandler) and TaskExecute
+        // (forwarded to the agent) so both sides observe a single consistent value
+        // even if the user toggles mid-task. Errors → undefined → fail-open enabled.
+        const reviewDisabled = await this.snapshotReviewDisabled(projectPath);
+        const taskAfterSnapshot = this.tasks.get(taskId);
+        if (taskAfterSnapshot && reviewDisabled !== undefined) {
+            this.tasks.set(taskId, { ...taskAfterSnapshot, reviewDisabled });
+        }
         const logId = await this.runCreateHooks(taskId);
         const task = this.tasks.get(taskId);
         if (task && logId) {
@@ -369,6 +382,7 @@ export class TaskRouter {
             ...(data.folderPath ? { folderPath: data.folderPath } : {}),
             ...(data.force === undefined ? {} : { force: data.force }),
             ...(projectPath ? { projectPath } : {}),
+            ...(reviewDisabled === undefined ? {} : { reviewDisabled }),
             taskId,
             type: data.type,
             ...(worktreeRoot ? { worktreeRoot } : {}),
@@ -683,4 +697,32 @@ export class TaskRouter {
         }));
         return logIds.find((id) => typeof id === 'string');
     }
+    /**
+     * Reads the project's reviewDisabled flag at task-create.
+     *
+     * Returns `undefined` only when no resolver is wired or no projectPath was
+     * resolved — those are legitimate "not configured" cases where downstream
+     * consumers fall back to their own resolution path.
+     *
+     * On resolver THROW, returns the explicit boolean `false` (review enabled =
+     * fail-open) so the daemon and the agent observe a single concrete value.
+     * Returning `undefined` here would re-introduce the exact divergence the
+     * snapshot is supposed to prevent: daemon stamps no field → CurateLogHandler
+     * uses `?? false` (enabled) while the agent process opens no ALS scope and
+     * may read `reviewDisabled: true` from `.brv/config.json` in the
+     * curate-tool fallback, producing pending review entries without backups
+     * (or vice versa). Aligns with the agent-side `isReviewDisabledForBrvDir`
+     * which also fails open.
+     */
+    async snapshotReviewDisabled(projectPath) {
+        if (!this.isReviewDisabled || !projectPath)
+            return undefined;
+        try {
+            return await this.isReviewDisabled(projectPath);
+        }
+        catch (error_) {
+            transportLog(`TaskRouter: isReviewDisabled resolver threw for ${projectPath} — defaulting to enabled: ${error_ instanceof Error ? error_.message : String(error_)}`);
+            return false;
+        }
+    }
 }

package/dist/server/infra/process/transport-handlers.d.ts

@@ -32,12 +32,14 @@ import type { ITaskLifecycleHook } from '../../core/interfaces/process/i-task-li
 import type { IProjectRegistry } from '../../core/interfaces/project/i-project-registry.js';
 import type { IProjectRouter } from '../../core/interfaces/routing/i-project-router.js';
 import type { ITransportServer } from '../../core/interfaces/transport/i-transport-server.js';
-import type { PreDispatchCheck } from './task-router.js';
-export type { PreDispatchCheck, PreDispatchCheckResult } from './task-router.js';
+import type { IsReviewDisabledResolver, PreDispatchCheck } from './task-router.js';
+export type { IsReviewDisabledResolver, PreDispatchCheck, PreDispatchCheckResult } from './task-router.js';
 export type { TaskInfo } from './types.js';
 type TransportHandlersOptions = {
     agentPool?: IAgentPool;
     clientManager?: IClientManager;
+    /** Resolves project's review-disabled flag at task-create. Snapshotted once into TaskInfo + TaskExecute. */
+    isReviewDisabled?: IsReviewDisabledResolver;
     /** Lifecycle hooks for task events (e.g. CurateLogHandler). */
     lifecycleHooks?: ITaskLifecycleHook[];
     /** Optional daemon-side gate run before dispatching a task to the agent pool. */

package/dist/server/infra/process/transport-handlers.js

@@ -41,6 +41,7 @@ export class TransportHandlers {
         this.taskRouter = new TaskRouter({
             agentPool: options.agentPool,
             getAgentForProject: (projectPath) => this.connectionCoordinator.getAgentForProject(projectPath),
+            isReviewDisabled: options.isReviewDisabled,
             lifecycleHooks: options.lifecycleHooks,
             preDispatchCheck: options.preDispatchCheck,
             projectRegistry: options.projectRegistry,

package/dist/server/infra/storage/file-provider-config-store.d.ts

@@ -27,13 +27,16 @@ export declare class FileProviderConfigStore implements IProviderConfigStore {
      */
     clearCache(): void;
     /**
-     * Marks a provider as connected.
+     * Marks a provider as connected. Defaults to also marking it as active —
+     * pass `setAsActive: false` to skip the activate step (used when the
+     * provider has no usable model yet).
      */
     connectProvider(providerId: string, options?: {
         activeModel?: string;
         authMethod?: 'api-key' | 'oauth';
         baseUrl?: string;
         oauthAccountId?: string;
+        setAsActive?: boolean;
     }): Promise<void>;
     /**
      * Removes a provider connection.

package/dist/server/infra/storage/file-provider-config-store.js

@@ -34,11 +34,14 @@ export class FileProviderConfigStore {
         this.cachedConfig = undefined;
     }
     /**
-     * Marks a provider as connected.
+     * Marks a provider as connected. Defaults to also marking it as active —
+     * pass `setAsActive: false` to skip the activate step (used when the
+     * provider has no usable model yet).
      */
     async connectProvider(providerId, options) {
         const config = await this.read();
-        const newConfig = config.withProviderConnected(providerId, options).withActiveProvider(providerId);
+        const connected = config.withProviderConnected(providerId, options);
+        const newConfig = options?.setAsActive === false ? connected : connected.withActiveProvider(providerId);
         await this.write(newConfig);
     }
     /**

package/dist/server/infra/transport/handlers/provider-handler.d.ts

@@ -22,6 +22,14 @@ export interface ProviderHandlerDeps {
     providerKeychainStore: IProviderKeychainStore;
     providerOAuthTokenStore: IProviderOAuthTokenStore;
     transport: ITransportServer;
+    /** Validator for openai-compatible base URL (injectable for testing) */
+    validateOpenAICompatibleEndpoint?: (params: {
+        apiKey: string;
+        baseUrl: string;
+    }) => Promise<{
+        error?: string;
+        isValid: boolean;
+    }>;
 }
 /**
  * Handles provider:* events.
@@ -38,6 +46,7 @@ export declare class ProviderHandler {
     private readonly providerKeychainStore;
     private readonly providerOAuthTokenStore;
     private readonly transport;
+    private readonly validateOpenAICompatibleEndpoint;
     constructor(deps: ProviderHandlerDeps);
     setup(): void;
     private cleanupFlowsForClient;

package/dist/server/infra/transport/handlers/provider-handler.js

@@ -4,7 +4,12 @@ import { TransportDaemonEventNames } from '../../../core/domain/transport/schema
 import { getErrorMessage } from '../../../utils/error-helpers.js';
 import { processLog } from '../../../utils/process-logger.js';
 import { validateApiKey as validateApiKeyViaFetcher } from '../../http/provider-model-fetcher-registry.js';
+import { OpenAICompatibleModelFetcher } from '../../http/provider-model-fetchers.js';
 import { computeExpiresAt, exchangeCodeForTokens as defaultExchangeCodeForTokens, generatePkce as defaultGeneratePkce, parseAccountIdFromIdToken, ProviderCallbackServer, ProviderCallbackTimeoutError, } from '../../provider-oauth/index.js';
+async function defaultValidateOpenAICompatibleEndpoint(params) {
+    const fetcher = new OpenAICompatibleModelFetcher(params.baseUrl, 'OpenAI Compatible');
+    return fetcher.validateApiKey(params.apiKey);
+}
 /**
  * Handles provider:* events.
  * Business logic for provider management — no terminal/UI calls.
@@ -20,6 +25,7 @@ export class ProviderHandler {
     providerKeychainStore;
     providerOAuthTokenStore;
     transport;
+    validateOpenAICompatibleEndpoint;
     constructor(deps) {
         this.authStateStore = deps.authStateStore;
         this.browserLauncher = deps.browserLauncher;
@@ -30,6 +36,8 @@ export class ProviderHandler {
         this.providerKeychainStore = deps.providerKeychainStore;
         this.providerOAuthTokenStore = deps.providerOAuthTokenStore;
         this.transport = deps.transport;
+        this.validateOpenAICompatibleEndpoint =
+            deps.validateOpenAICompatibleEndpoint ?? defaultValidateOpenAICompatibleEndpoint;
     }
     setup() {
         this.setupConnect();
@@ -142,15 +150,50 @@ export class ProviderHandler {
             if (providerId === 'byterover' && !this.isByteRoverAuthSatisfied()) {
                 return { error: 'ByteRover Provider requires authentication. Run /login or brv login to sign in', success: false };
             }
+            // Verify openai-compatible endpoint is reachable before persisting anything —
+            // a failed setup must not leave a placeholder config that masquerades as
+            // connected. Falls back to existing baseUrl/keychain key on reconfigure
+            // when the request omits them, so a partial reconfigure (e.g. only changing
+            // the URL) still validates with the user's stored credentials.
+            if (providerId === 'openai-compatible') {
+                const existingBaseUrl = await this.providerConfigStore.read().then((c) => c.getBaseUrl(providerId));
+                const effectiveBaseUrl = baseUrl ?? existingBaseUrl;
+                if (!effectiveBaseUrl) {
+                    return {
+                        error: 'A base URL is required for OpenAI-compatible providers (e.g. http://localhost:11434/v1)',
+                        success: false,
+                    };
+                }
+                const effectiveApiKey = apiKey ?? (await this.providerKeychainStore.getApiKey(providerId)) ?? '';
+                const validation = await this.validateOpenAICompatibleEndpoint({
+                    apiKey: effectiveApiKey,
+                    baseUrl: effectiveBaseUrl,
+                });
+                if (!validation.isValid) {
+                    const detail = validation.error ? `: ${validation.error}` : '';
+                    return {
+                        error: `Could not reach OpenAI-compatible endpoint at ${effectiveBaseUrl}${detail}`,
+                        success: false,
+                    };
+                }
+            }
             // Store API key if provided (supports optional keys for openai-compatible)
             if (apiKey) {
                 await this.providerKeychainStore.setApiKey(providerId, apiKey);
             }
             const provider = getProviderById(providerId);
+            // Skip activating the provider when it ends up with no active model —
+            // the welcome view treats `activeProvider w/o activeModel` as
+            // "needs setup" and unmounts any in-flight setup flow on the home
+            // page. The model:setActive handler activates the provider when the
+            // user picks a model, which is the right moment.
+            const willHaveActiveModel = Boolean(provider?.defaultModel)
+                || Boolean(await this.providerConfigStore.getActiveModel(providerId));
             await this.providerConfigStore.connectProvider(providerId, {
                 activeModel: provider?.defaultModel,
                 authMethod: apiKey ? 'api-key' : undefined,
                 baseUrl,
+                setAsActive: willHaveActiveModel,
             });
             this.transport.broadcast(TransportDaemonEventNames.PROVIDER_UPDATED, {});
             return { success: true };
@@ -186,6 +229,7 @@ export class ProviderHandler {
                 const providerConfig = config?.providers[def.id];
                 const authMethod = providerConfig?.authMethod;
                 return {
+                    activeModel: providerConfig?.activeModel,
                     apiKeyUrl: def.apiKeyUrl,
                     authMethod,
                     category: def.category,

package/dist/server/infra/transport/handlers/review-handler.d.ts

@@ -1,4 +1,5 @@
 import type { ICurateLogStore } from '../../../core/interfaces/storage/i-curate-log-store.js';
+import type { IProjectConfigStore } from '../../../core/interfaces/storage/i-project-config-store.js';
 import type { IReviewBackupStore } from '../../../core/interfaces/storage/i-review-backup-store.js';
 import type { ITransportServer } from '../../../core/interfaces/transport/i-transport-server.js';
 import { type ProjectPathResolver } from './handler-types.js';
@@ -11,6 +12,7 @@ export interface ReviewHandlerDeps {
         projectPath: string;
         taskId: string;
     }) => void;
+    projectConfigStore: IProjectConfigStore;
     resolveProjectPath: ProjectPathResolver;
     reviewBackupStoreFactory: ReviewBackupStoreFactory;
     transport: ITransportServer;
@@ -24,12 +26,15 @@ export interface ReviewHandlerDeps {
 export declare class ReviewHandler {
     private readonly curateLogStoreFactory;
     private readonly onResolved;
+    private readonly projectConfigStore;
     private readonly resolveProjectPath;
     private readonly reviewBackupStoreFactory;
     private readonly transport;
     constructor(deps: ReviewHandlerDeps);
     setup(): void;
     private handleDecideTask;
+    private handleGetDisabled;
     private handlePending;
+    private handleSetDisabled;
 }
 export {};

package/dist/server/infra/transport/handlers/review-handler.js

@@ -18,19 +18,23 @@ async function writeFileWithDirs(absolutePath, content) {
 export class ReviewHandler {
     curateLogStoreFactory;
     onResolved;
+    projectConfigStore;
     resolveProjectPath;
     reviewBackupStoreFactory;
     transport;
     constructor(deps) {
         this.curateLogStoreFactory = deps.curateLogStoreFactory;
         this.onResolved = deps.onResolved;
+        this.projectConfigStore = deps.projectConfigStore;
         this.resolveProjectPath = deps.resolveProjectPath;
         this.reviewBackupStoreFactory = deps.reviewBackupStoreFactory;
         this.transport = deps.transport;
     }
     setup() {
         this.transport.onRequest(ReviewEvents.DECIDE_TASK, (data, clientId) => this.handleDecideTask(data, clientId));
+        this.transport.onRequest(ReviewEvents.GET_DISABLED, (_data, clientId) => this.handleGetDisabled(clientId));
         this.transport.onRequest(ReviewEvents.PENDING, (_data, clientId) => this.handlePending(clientId));
+        this.transport.onRequest(ReviewEvents.SET_DISABLED, (data, clientId) => this.handleSetDisabled(data, clientId));
     }
     async handleDecideTask({ decision, filePaths: filterPaths, taskId }, clientId) {
         const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
@@ -119,6 +123,14 @@ export class ReviewHandler {
         const totalCount = fileResults.reduce((sum, { ops }) => sum + ops.length, 0);
         return { files: fileResults.map(({ path, reverted }) => ({ path, reverted })), totalCount };
     }
+    async handleGetDisabled(clientId) {
+        const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        const config = await this.projectConfigStore.read(projectPath);
+        if (!config) {
+            throw new Error(`Project not initialized: ${projectPath}. Run \`brv init\` first.`);
+        }
+        return { reviewDisabled: config.reviewDisabled === true };
+    }
     async handlePending(clientId) {
         const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
         const contextTreeDir = join(projectPath, BRV_DIR, CONTEXT_TREE_DIR);
@@ -159,4 +171,14 @@ export class ReviewHandler {
         const pendingCount = tasks.reduce((sum, t) => sum + t.operations.length, 0);
         return { pendingCount, tasks };
     }
+    async handleSetDisabled({ reviewDisabled }, clientId) {
+        const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        const config = await this.projectConfigStore.read(projectPath);
+        if (!config) {
+            throw new Error(`Project not initialized: ${projectPath}. Run \`brv init\` first.`);
+        }
+        const updated = config.withReviewDisabled(reviewDisabled);
+        await this.projectConfigStore.write(updated, projectPath);
+        return { reviewDisabled };
+    }
 }

package/dist/shared/transport/events/index.d.ts

@@ -124,8 +124,10 @@ export declare const AllEventGroups: readonly [{
     readonly EXECUTE: "reset:execute";
 }, {
     readonly DECIDE_TASK: "review:decideTask";
+    readonly GET_DISABLED: "review:getDisabled";
     readonly NOTIFY: "review:notify";
     readonly PENDING: "review:pending";
+    readonly SET_DISABLED: "review:setDisabled";
 }, {
     readonly SWITCHED: "session:switched";
 }, {

package/dist/shared/transport/events/review-events.d.ts

@@ -1,8 +1,19 @@
 export declare const ReviewEvents: {
     readonly DECIDE_TASK: "review:decideTask";
+    readonly GET_DISABLED: "review:getDisabled";
     readonly NOTIFY: "review:notify";
     readonly PENDING: "review:pending";
+    readonly SET_DISABLED: "review:setDisabled";
 };
+export interface ReviewGetDisabledResponse {
+    reviewDisabled: boolean;
+}
+export interface ReviewSetDisabledRequest {
+    reviewDisabled: boolean;
+}
+export interface ReviewSetDisabledResponse {
+    reviewDisabled: boolean;
+}
 export interface ReviewNotifyEvent {
     pendingCount: number;
     reviewUrl: string;

package/dist/shared/transport/events/review-events.js

@@ -1,5 +1,7 @@
 export const ReviewEvents = {
     DECIDE_TASK: 'review:decideTask',
+    GET_DISABLED: 'review:getDisabled',
     NOTIFY: 'review:notify',
     PENDING: 'review:pending',
+    SET_DISABLED: 'review:setDisabled',
 };

package/dist/shared/transport/types/dto.d.ts

@@ -50,6 +50,8 @@ export interface ConnectorDTO {
     supportedTypes: ConnectorType[];
 }
 export interface ProviderDTO {
+    /** Currently selected model for this provider, if any. Absent means connected but model not yet picked. */
+    activeModel?: string;
     apiKeyUrl?: string;
     authMethod?: 'api-key' | 'oauth';
     category: 'other' | 'popular';

package/dist/tui/features/provider/components/provider-flow.js

@@ -29,6 +29,16 @@ import { BaseUrlDialog } from './base-url-dialog.js';
 import { ModelSelectStep } from './model-select-step.js';
 import { OAuthDialog } from './oauth-dialog.js';
 import { ProviderDialog } from './provider-dialog.js';
+/**
+ * Throws on transport responses that ack with `success: false` so the
+ * existing try/catch surfaces server-side errors instead of silently
+ * marching forward into the next step.
+ */
+function ensureSuccess(response) {
+    if (!response.success) {
+        throw new Error(response.error ?? 'Operation failed');
+    }
+}
 export const ProviderFlow = ({ hideCancelButton = false, isActive = true, onCancel, onComplete, providerDialogTitle, }) => {
     const { theme: { colors } } = useTheme();
     const [step, setStep] = useState('select');
@@ -113,9 +123,17 @@ export const ProviderFlow = ({ hideCancelButton = false, isActive = true, onCanc
             onComplete(`Connected to ${provider.name}`);
             return;
         }
-        // Already connected → show actions menu
+        // Already connected → show actions menu. Exception: openai-compatible
+        // is the only provider that can land in a connected-but-no-active-model
+        // state (no canonical defaultModel exists for arbitrary endpoints), so
+        // when it's the current provider we jump straight to the model picker
+        // so the welcome view's user can finish setup. For non-current
+        // half-configured providers we still show the actions menu so
+        // Disconnect / Set as active stay reachable (the picker would otherwise
+        // be a dead-end if the endpoint is down).
         if (provider.isConnected) {
-            setStep('provider_actions');
+            const needsModelPick = provider.id === 'openai-compatible' && !provider.activeModel && provider.isCurrent;
+            setStep(needsModelPick ? 'model_select' : 'provider_actions');
             return;
         }
         // ByteRover + not connected → connect + activate directly, no model select
@@ -249,16 +267,23 @@ export const ProviderFlow = ({ hideCancelButton = false, isActive = true, onCanc
             return;
         setStep('connecting');
         try {
-            await connectMutation.mutateAsync({
+            ensureSuccess(await connectMutation.mutateAsync({
                 apiKey: apiKey || undefined,
                 baseUrl: baseUrl || undefined,
                 providerId: selectedProvider.id,
-            });
+            }));
             setStep('model_select');
         }
         catch (error_) {
             setError(formatTransportError(error_));
-            setStep('api_key');
+            // Server rejection (e.g. unreachable openai-compatible URL) — return to
+            // the provider list where the error is rendered. The user can re-enter
+            // the flow with a corrected URL or API key. Mirror the other failure
+            // paths (e.g. handleSelect at the byterover branch) by clearing the
+            // selected provider too.
+            setStep('select');
+            setSelectedProvider(null);
+            setBaseUrl(null);
         }
     }, [baseUrl, connectMutation, selectedProvider]);
     const handleApiKeyCancel = useCallback(() => {

package/node_modules/@tanstack/query-core/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Tanner Linsley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@tanstack/query-core/build/legacy/chunk-PXG64RU4.js

@@ -0,0 +1,25 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+
+export {
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateMethod,
+  __privateWrapper
+};
+//# sourceMappingURL=chunk-PXG64RU4.js.map

package/node_modules/@tanstack/query-core/build/legacy/chunk-PXG64RU4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/node_modules/@tanstack/query-core/build/legacy/focusManager.cjs

@@ -0,0 +1,108 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+// src/focusManager.ts
+var focusManager_exports = {};
+__export(focusManager_exports, {
+  FocusManager: () => FocusManager,
+  focusManager: () => focusManager
+});
+module.exports = __toCommonJS(focusManager_exports);
+var import_subscribable = require("./subscribable.cjs");
+var import_utils = require("./utils.cjs");
+var _focused, _cleanup, _setup;
+var FocusManager = class extends import_subscribable.Subscribable {
+  constructor() {
+    super();
+    __privateAdd(this, _focused);
+    __privateAdd(this, _cleanup);
+    __privateAdd(this, _setup);
+    __privateSet(this, _setup, (onFocus) => {
+      if (!import_utils.isServer && window.addEventListener) {
+        const listener = () => onFocus();
+        window.addEventListener("visibilitychange", listener, false);
+        return () => {
+          window.removeEventListener("visibilitychange", listener);
+        };
+      }
+      return;
+    });
+  }
+  onSubscribe() {
+    if (!__privateGet(this, _cleanup)) {
+      this.setEventListener(__privateGet(this, _setup));
+    }
+  }
+  onUnsubscribe() {
+    var _a;
+    if (!this.hasListeners()) {
+      (_a = __privateGet(this, _cleanup)) == null ? void 0 : _a.call(this);
+      __privateSet(this, _cleanup, void 0);
+    }
+  }
+  setEventListener(setup) {
+    var _a;
+    __privateSet(this, _setup, setup);
+    (_a = __privateGet(this, _cleanup)) == null ? void 0 : _a.call(this);
+    __privateSet(this, _cleanup, setup((focused) => {
+      if (typeof focused === "boolean") {
+        this.setFocused(focused);
+      } else {
+        this.onFocus();
+      }
+    }));
+  }
+  setFocused(focused) {
+    const changed = __privateGet(this, _focused) !== focused;
+    if (changed) {
+      __privateSet(this, _focused, focused);
+      this.onFocus();
+    }
+  }
+  onFocus() {
+    const isFocused = this.isFocused();
+    this.listeners.forEach((listener) => {
+      listener(isFocused);
+    });
+  }
+  isFocused() {
+    var _a;
+    if (typeof __privateGet(this, _focused) === "boolean") {
+      return __privateGet(this, _focused);
+    }
+    return ((_a = globalThis.document) == null ? void 0 : _a.visibilityState) !== "hidden";
+  }
+};
+_focused = new WeakMap();
+_cleanup = new WeakMap();
+_setup = new WeakMap();
+var focusManager = new FocusManager();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FocusManager,
+  focusManager
+});
+//# sourceMappingURL=focusManager.cjs.map

package/node_modules/@tanstack/query-core/build/legacy/focusManager.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/focusManager.ts"],"sourcesContent":["import { Subscribable } from './subscribable'\nimport { isServer } from './utils'\n\ntype Listener = (focused: boolean) => void\n\ntype SetupFn = (\n  setFocused: (focused?: boolean) => void,\n) => (() => void) | undefined\n\nexport class FocusManager extends Subscribable<Listener> {\n  #focused?: boolean\n  #cleanup?: () => void\n\n  #setup: SetupFn\n\n  constructor() {\n    super()\n    this.#setup = (onFocus) => {\n      // addEventListener does not exist in React Native, but window does\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n      if (!isServer && window.addEventListener) {\n        const listener = () => onFocus()\n        // Listen to visibilitychange\n        window.addEventListener('visibilitychange', listener, false)\n\n        return () => {\n          // Be sure to unsubscribe if a new handler is set\n          window.removeEventListener('visibilitychange', listener)\n        }\n      }\n      return\n    }\n  }\n\n  protected onSubscribe(): void {\n    if (!this.#cleanup) {\n      this.setEventListener(this.#setup)\n    }\n  }\n\n  protected onUnsubscribe() {\n    if (!this.hasListeners()) {\n      this.#cleanup?.()\n      this.#cleanup = undefined\n    }\n  }\n\n  setEventListener(setup: SetupFn): void {\n    this.#setup = setup\n    this.#cleanup?.()\n    this.#cleanup = setup((focused) => {\n      if (typeof focused === 'boolean') {\n        this.setFocused(focused)\n      } else {\n        this.onFocus()\n      }\n    })\n  }\n\n  setFocused(focused?: boolean): void {\n    const changed = this.#focused !== focused\n    if (changed) {\n      this.#focused = focused\n      this.onFocus()\n    }\n  }\n\n  onFocus(): void {\n    const isFocused = this.isFocused()\n    this.listeners.forEach((listener) => {\n      listener(isFocused)\n    })\n  }\n\n  isFocused(): boolean {\n    if (typeof this.#focused === 'boolean') {\n      return this.#focused\n    }\n\n    // document global can be unavailable in react native\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n    return globalThis.document?.visibilityState !== 'hidden'\n  }\n}\n\nexport const focusManager = new FocusManager()\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0BAA6B;AAC7B,mBAAyB;AADzB;AASO,IAAM,eAAN,cAA2B,iCAAuB;AAAA,EAMvD,cAAc;AACZ,UAAM;AANR;AACA;AAEA;AAIE,uBAAK,QAAS,CAAC,YAAY;AAGzB,UAAI,CAAC,yBAAY,OAAO,kBAAkB;AACxC,cAAM,WAAW,MAAM,QAAQ;AAE/B,eAAO,iBAAiB,oBAAoB,UAAU,KAAK;AAE3D,eAAO,MAAM;AAEX,iBAAO,oBAAoB,oBAAoB,QAAQ;AAAA,QACzD;AAAA,MACF;AACA;AAAA,IACF;AAAA,EACF;AAAA,EAEU,cAAoB;AAC5B,QAAI,CAAC,mBAAK,WAAU;AAClB,WAAK,iBAAiB,mBAAK,OAAM;AAAA,IACnC;AAAA,EACF;AAAA,EAEU,gBAAgB;AAxC5B;AAyCI,QAAI,CAAC,KAAK,aAAa,GAAG;AACxB,+BAAK,cAAL;AACA,yBAAK,UAAW;AAAA,IAClB;AAAA,EACF;AAAA,EAEA,iBAAiB,OAAsB;AA/CzC;AAgDI,uBAAK,QAAS;AACd,6BAAK,cAAL;AACA,uBAAK,UAAW,MAAM,CAAC,YAAY;AACjC,UAAI,OAAO,YAAY,WAAW;AAChC,aAAK,WAAW,OAAO;AAAA,MACzB,OAAO;AACL,aAAK,QAAQ;AAAA,MACf;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,WAAW,SAAyB;AAClC,UAAM,UAAU,mBAAK,cAAa;AAClC,QAAI,SAAS;AACX,yBAAK,UAAW;AAChB,WAAK,QAAQ;AAAA,IACf;AAAA,EACF;AAAA,EAEA,UAAgB;AACd,UAAM,YAAY,KAAK,UAAU;AACjC,SAAK,UAAU,QAAQ,CAAC,aAAa;AACnC,eAAS,SAAS;AAAA,IACpB,CAAC;AAAA,EACH;AAAA,EAEA,YAAqB;AA1EvB;AA2EI,QAAI,OAAO,mBAAK,cAAa,WAAW;AACtC,aAAO,mBAAK;AAAA,IACd;AAIA,aAAO,gBAAW,aAAX,mBAAqB,qBAAoB;AAAA,EAClD;AACF;AAzEE;AACA;AAEA;AAwEK,IAAM,eAAe,IAAI,aAAa;","names":[]}

package/node_modules/@tanstack/query-core/build/legacy/focusManager.d.cts

@@ -0,0 +1,17 @@
+import { Subscribable } from './subscribable.cjs';
+
+type Listener = (focused: boolean) => void;
+type SetupFn = (setFocused: (focused?: boolean) => void) => (() => void) | undefined;
+declare class FocusManager extends Subscribable<Listener> {
+    #private;
+    constructor();
+    protected onSubscribe(): void;
+    protected onUnsubscribe(): void;
+    setEventListener(setup: SetupFn): void;
+    setFocused(focused?: boolean): void;
+    onFocus(): void;
+    isFocused(): boolean;
+}
+declare const focusManager: FocusManager;
+
+export { FocusManager, focusManager };