chore: import upstream snapshot with attribution
This commit is contained in:
wehub-resource-sync
@@ -0,0 +1,361 @@
|
||||
import AppKit
|
||||
import CodexBarCore
|
||||
import QuartzCore
|
||||
|
||||
extension StatusItemController {
|
||||
private static let providerSwitcherMenuRebuildDebounceNanoseconds: UInt64 = 0
|
||||
|
||||
private struct ScheduledOpenMenuRebuild {
|
||||
let provider: UsageProvider?
|
||||
let shouldCloseHostedSubviewMenus: Bool
|
||||
let beforeRebuild: (@MainActor () -> Bool)?
|
||||
}
|
||||
|
||||
func didMenuAdjunctReadinessChange() -> Bool {
|
||||
let signature = self.menuAdjunctReadinessSignature()
|
||||
defer { self.recordMenuAdjunctReadinessBaseline(signature) }
|
||||
return signature != self.lastMenuAdjunctReadinessSignature
|
||||
}
|
||||
|
||||
/// Resyncs the readiness baseline to the data the menu was just built from.
|
||||
///
|
||||
/// Because the baseline is no longer recomputed on every store change while all menus are closed,
|
||||
/// it can drift from the live store state. When a root menu opens and is actually rebuilt (or is
|
||||
/// already fresh for the current `menuContentVersion`), the baseline must be re-anchored here;
|
||||
/// otherwise a later open-menu store change that happens to revert to the stale baseline value would
|
||||
/// be treated as "unchanged" and skip a needed rebuild, leaving the visible menu showing the older
|
||||
/// content. Callers must **not** invoke this when `refreshMenuForOpenIfNeeded` preserved stale
|
||||
/// content during an in-flight refresh — that would record live store data while the visible menu
|
||||
/// still shows older content and mask the refresh-completion update.
|
||||
func resyncMenuAdjunctReadinessBaseline() {
|
||||
self.recordMenuAdjunctReadinessBaseline(self.menuAdjunctReadinessSignature())
|
||||
}
|
||||
|
||||
/// Resyncs a root-menu baseline after open and handles the narrow race where a store change
|
||||
/// has updated live data but its deferred observation task has not invalidated menus yet.
|
||||
///
|
||||
/// If a previously fresh menu sees new live data before the observer version tick, invalidate all
|
||||
/// menus first and rebuild only the opened menu. The matching observer can then skip the expensive
|
||||
/// readiness comparison while still invalidating menu-observed state that is not in the signature.
|
||||
func resyncMenuAdjunctReadinessBaselineForRootOpen(
|
||||
_ menu: NSMenu,
|
||||
provider: UsageProvider?,
|
||||
menuWasFreshBeforeOpen: Bool)
|
||||
{
|
||||
let signature = self.menuAdjunctReadinessSignature()
|
||||
let menuKey = ObjectIdentifier(menu)
|
||||
let menuRenderedCurrentSignature =
|
||||
self.menuSession.renderedVersion(for: menuKey) == self.menuSession.contentVersion &&
|
||||
self.menuReadinessSignatures[menuKey] == signature
|
||||
guard signature != self.lastMenuAdjunctReadinessSignature else {
|
||||
guard menuWasFreshBeforeOpen, !menuRenderedCurrentSignature else {
|
||||
self.lastMenuAdjunctReadinessBaselineVersion = self.menuSession.contentVersion
|
||||
return
|
||||
}
|
||||
guard !self.isMenuDataRefreshInFlight else { return }
|
||||
self.invalidateMenus()
|
||||
self.populateMenu(menu, provider: provider)
|
||||
self.markMenuFresh(menu)
|
||||
self.rememberRootOpenHandledMenuObservation(signature: signature)
|
||||
self.recordMenuAdjunctReadinessBaseline(signature)
|
||||
return
|
||||
}
|
||||
|
||||
if menuWasFreshBeforeOpen {
|
||||
if self.isMenuDataRefreshInFlight, !menuRenderedCurrentSignature {
|
||||
return
|
||||
}
|
||||
if menuRenderedCurrentSignature {
|
||||
self.recordMenuAdjunctReadinessBaseline(signature)
|
||||
return
|
||||
}
|
||||
self.invalidateMenus()
|
||||
self.populateMenu(menu, provider: provider)
|
||||
self.markMenuFresh(menu)
|
||||
self.rememberRootOpenHandledMenuObservation(signature: signature)
|
||||
}
|
||||
self.recordMenuAdjunctReadinessBaseline(signature)
|
||||
}
|
||||
|
||||
private func recordMenuAdjunctReadinessBaseline(_ signature: String) {
|
||||
self.lastMenuAdjunctReadinessSignature = signature
|
||||
self.lastMenuAdjunctReadinessBaselineVersion = self.menuSession.contentVersion
|
||||
}
|
||||
|
||||
private func rememberRootOpenHandledMenuObservation(signature: String) {
|
||||
self.rootOpenHandledMenuObservationSignature = signature
|
||||
Task { @MainActor [weak self] in
|
||||
await Task.yield()
|
||||
if self?.rootOpenHandledMenuObservationSignature == signature {
|
||||
self?.rootOpenHandledMenuObservationSignature = nil
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func consumeRootOpenHandledMenuObservationIfNeeded() -> Bool {
|
||||
guard let handledSignature = self.rootOpenHandledMenuObservationSignature else { return false }
|
||||
let signature = self.menuAdjunctReadinessSignature()
|
||||
guard signature == handledSignature else {
|
||||
self.rootOpenHandledMenuObservationSignature = nil
|
||||
return false
|
||||
}
|
||||
self.rootOpenHandledMenuObservationSignature = nil
|
||||
self.recordMenuAdjunctReadinessBaseline(signature)
|
||||
return true
|
||||
}
|
||||
|
||||
func menuAdjunctReadinessSignature() -> String {
|
||||
let dashboard = self.store.openAIDashboard
|
||||
let dashboardUsageBreakdown = OpenAIDashboardDailyBreakdown.removingSkillUsageServices(
|
||||
from: dashboard?.usageBreakdown ?? [])
|
||||
var parts = [
|
||||
"costEnabled=\(self.settings.costUsageEnabled ? "1" : "0")",
|
||||
"costStyle=\(self.settings.costSummaryDisplayStyle.rawValue)",
|
||||
"openAIAttached=\(self.store.openAIDashboardAttachmentAuthorized ? "1" : "0")",
|
||||
"openAILogin=\(self.store.openAIDashboardRequiresLogin ? "1" : "0")",
|
||||
"openAIUpdated=\(Self.millisecondsSinceEpoch(dashboard?.updatedAt))",
|
||||
"openAIDaily=\(Self.dashboardBreakdownReadinessSignature(dashboard?.dailyBreakdown ?? []))",
|
||||
"openAIUsage=\(Self.dashboardBreakdownReadinessSignature(dashboardUsageBreakdown))",
|
||||
"credits=\(self.store.credits == nil ? "0" : "1")",
|
||||
"planHistoryRevision=\(self.store.planUtilizationHistoryRevision)",
|
||||
"claudeSwapRevision=\(self.store.claudeSwapRevision)",
|
||||
]
|
||||
|
||||
for provider in self.store.enabledProvidersForDisplay() {
|
||||
let tokenSignature = self.tokenSnapshotReadinessSignature(for: provider)
|
||||
let usageHistoryVisible = self.store.supportsPlanUtilizationHistory(for: provider) &&
|
||||
!self.store.shouldHidePlanUtilizationMenuItem(for: provider)
|
||||
parts.append(
|
||||
[
|
||||
provider.rawValue,
|
||||
"token=\(tokenSignature)",
|
||||
"statusComponents=\(self.statusComponentsRenderSignature(for: provider))",
|
||||
"refreshing=\(self.store.shouldShowRefreshingMenuCardIndicator(for: provider) ? "1" : "0")",
|
||||
"usageHistory=\(usageHistoryVisible ? "1" : "0")",
|
||||
].joined(separator: ":"))
|
||||
}
|
||||
|
||||
return parts.joined(separator: "|")
|
||||
}
|
||||
|
||||
static func dashboardBreakdownReadinessSignature(
|
||||
_ breakdown: [OpenAIDashboardDailyBreakdown]) -> String
|
||||
{
|
||||
breakdown
|
||||
.map { day in
|
||||
let services = day.services
|
||||
.map { "\($0.service)=\(Self.formatDoubleForSignature($0.creditsUsed))" }
|
||||
.joined(separator: ",")
|
||||
return [
|
||||
day.day,
|
||||
Self.formatDoubleForSignature(day.totalCreditsUsed),
|
||||
services,
|
||||
].joined(separator: ":")
|
||||
}
|
||||
.joined(separator: ";")
|
||||
}
|
||||
|
||||
private func tokenSnapshotReadinessSignature(for provider: UsageProvider) -> String {
|
||||
guard let snapshot = self.store.tokenSnapshot(for: provider) else { return "none" }
|
||||
let daily = snapshot.daily
|
||||
.map { entry in
|
||||
[
|
||||
entry.date,
|
||||
"\(entry.totalTokens ?? -1)",
|
||||
Self.formatOptionalDoubleForSignature(entry.costUSD),
|
||||
].joined(separator: ",")
|
||||
}
|
||||
.joined(separator: ";")
|
||||
let projects = snapshot.projects
|
||||
.map { project in
|
||||
let sources = project.sources
|
||||
.map { source in
|
||||
[
|
||||
source.name,
|
||||
source.path ?? "",
|
||||
"\(source.totalTokens ?? -1)",
|
||||
Self.formatOptionalDoubleForSignature(source.totalCostUSD),
|
||||
].joined(separator: ",")
|
||||
}
|
||||
.joined(separator: "|")
|
||||
return [
|
||||
project.name,
|
||||
project.path ?? "",
|
||||
"\(project.totalTokens ?? -1)",
|
||||
Self.formatOptionalDoubleForSignature(project.totalCostUSD),
|
||||
sources,
|
||||
].joined(separator: ",")
|
||||
}
|
||||
.joined(separator: ";")
|
||||
return [
|
||||
"sessionTokens=\(snapshot.sessionTokens ?? -1)",
|
||||
"sessionCost=\(Self.formatOptionalDoubleForSignature(snapshot.sessionCostUSD))",
|
||||
"lastTokens=\(snapshot.last30DaysTokens ?? -1)",
|
||||
"lastCost=\(Self.formatOptionalDoubleForSignature(snapshot.last30DaysCostUSD))",
|
||||
"updated=\(Int(snapshot.updatedAt.timeIntervalSince1970 * 1000))",
|
||||
"daily=\(daily)",
|
||||
"projects=\(projects)",
|
||||
].joined(separator: ",")
|
||||
}
|
||||
|
||||
private static func millisecondsSinceEpoch(_ date: Date?) -> Int {
|
||||
guard let date else { return -1 }
|
||||
return Int(date.timeIntervalSince1970 * 1000)
|
||||
}
|
||||
|
||||
private static func formatOptionalDoubleForSignature(_ value: Double?) -> String {
|
||||
guard let value else { return "nil" }
|
||||
return self.formatDoubleForSignature(value)
|
||||
}
|
||||
|
||||
/// The signature is only ever compared for equality against the previous signature, so it does
|
||||
/// not need a human-readable decimal form. `String(format: "%.8f", …)` is a surprisingly hot
|
||||
/// cost here because it runs for every daily/service value across every enabled provider on each
|
||||
/// store mutation. The raw bit pattern is both exact (no rounding collisions) and far cheaper.
|
||||
private static func formatDoubleForSignature(_ value: Double) -> String {
|
||||
String(value.bitPattern, radix: 16)
|
||||
}
|
||||
|
||||
func performMenuMutationWithoutAnimation(_ updates: () -> Void) {
|
||||
CATransaction.begin()
|
||||
CATransaction.setDisableActions(true)
|
||||
defer { CATransaction.commit() }
|
||||
updates()
|
||||
}
|
||||
|
||||
func deferSwitcherMenuRebuildIfStillVisible(_ menu: NSMenu, provider: UsageProvider?) {
|
||||
self.providerSwitcherUpdateToken &+= 1
|
||||
let updateToken = self.providerSwitcherUpdateToken
|
||||
#if DEBUG
|
||||
let debounceNanoseconds = self._test_providerSwitcherMenuRebuildDebounceNanoseconds ?? (
|
||||
self._test_openMenuRebuildObserver == nil ? Self.providerSwitcherMenuRebuildDebounceNanoseconds : 0)
|
||||
#else
|
||||
let debounceNanoseconds = Self.providerSwitcherMenuRebuildDebounceNanoseconds
|
||||
#endif
|
||||
#if DEBUG
|
||||
let usesTaskSchedulerForTesting = self._test_openMenuRefreshYieldOverride != nil
|
||||
|| self._test_openMenuRebuildObserver != nil
|
||||
#else
|
||||
let usesTaskSchedulerForTesting = false
|
||||
#endif
|
||||
if debounceNanoseconds == 0, !usesTaskSchedulerForTesting {
|
||||
self.scheduleProviderSwitcherTrackingMenuRebuildIfStillVisible(
|
||||
menu,
|
||||
provider: provider)
|
||||
{ [weak self] in
|
||||
guard let self else { return false }
|
||||
return self.providerSwitcherUpdateToken == updateToken
|
||||
}
|
||||
return
|
||||
}
|
||||
self.scheduleOpenMenuRebuildIfStillVisible(
|
||||
menu,
|
||||
provider: provider,
|
||||
closeHostedSubviewMenusBeforeRebuild: true,
|
||||
debounceNanoseconds: debounceNanoseconds)
|
||||
{ [weak self] in
|
||||
guard let self else { return false }
|
||||
return self.providerSwitcherUpdateToken == updateToken
|
||||
}
|
||||
}
|
||||
|
||||
private func scheduleProviderSwitcherTrackingMenuRebuildIfStillVisible(
|
||||
_ menu: NSMenu,
|
||||
provider: UsageProvider?,
|
||||
beforeRebuild: @escaping @MainActor () -> Bool)
|
||||
{
|
||||
let key = ObjectIdentifier(menu)
|
||||
self.openMenuRebuildsClosingHostedSubviewMenus.insert(key)
|
||||
let rebuildToken = self.openMenuRebuildRequests.replaceRequest(for: key)
|
||||
self.openMenuRebuildTasks.removeValue(forKey: key)?.cancel()
|
||||
|
||||
ProviderSwitcherTrackingRunLoopScheduler.schedule { [weak self, weak menu] in
|
||||
guard let self, let menu else { return }
|
||||
self.performScheduledOpenMenuRebuild(
|
||||
menu,
|
||||
key: key,
|
||||
rebuildToken: rebuildToken,
|
||||
request: ScheduledOpenMenuRebuild(
|
||||
provider: provider,
|
||||
shouldCloseHostedSubviewMenus: true,
|
||||
beforeRebuild: beforeRebuild))
|
||||
}
|
||||
}
|
||||
|
||||
func scheduleOpenMenuRebuildIfStillVisible(
|
||||
_ menu: NSMenu,
|
||||
provider: UsageProvider?,
|
||||
closeHostedSubviewMenusBeforeRebuild: Bool = false,
|
||||
resyncReadinessBaselineAfterRebuild: Bool = false,
|
||||
debounceNanoseconds: UInt64 = 0,
|
||||
beforeRebuild: (@MainActor () -> Bool)? = nil)
|
||||
{
|
||||
let key = ObjectIdentifier(menu)
|
||||
if resyncReadinessBaselineAfterRebuild {
|
||||
self.pendingMenuBaselineResyncs.insert(key)
|
||||
}
|
||||
if closeHostedSubviewMenusBeforeRebuild {
|
||||
self.openMenuRebuildsClosingHostedSubviewMenus.insert(key)
|
||||
}
|
||||
let shouldCloseHostedSubviewMenus = self.openMenuRebuildsClosingHostedSubviewMenus.contains(key)
|
||||
let rebuildToken = self.openMenuRebuildRequests.replaceRequest(for: key)
|
||||
self.openMenuRebuildTasks[key]?.cancel()
|
||||
self.openMenuRebuildTasks[key] = Task { @MainActor [weak self, weak menu] in
|
||||
guard let self, let menu else { return }
|
||||
#if DEBUG
|
||||
if let override = self._test_openMenuRefreshYieldOverride {
|
||||
await override()
|
||||
} else {
|
||||
await Task.yield()
|
||||
}
|
||||
#else
|
||||
await Task.yield()
|
||||
#endif
|
||||
if debounceNanoseconds > 0 {
|
||||
try? await Task.sleep(nanoseconds: debounceNanoseconds)
|
||||
}
|
||||
guard !Task.isCancelled else { return }
|
||||
self.performScheduledOpenMenuRebuild(
|
||||
menu,
|
||||
key: key,
|
||||
rebuildToken: rebuildToken,
|
||||
request: ScheduledOpenMenuRebuild(
|
||||
provider: provider,
|
||||
shouldCloseHostedSubviewMenus: shouldCloseHostedSubviewMenus,
|
||||
beforeRebuild: beforeRebuild))
|
||||
}
|
||||
}
|
||||
|
||||
private func performScheduledOpenMenuRebuild(
|
||||
_ menu: NSMenu,
|
||||
key: ObjectIdentifier,
|
||||
rebuildToken: Int,
|
||||
request: ScheduledOpenMenuRebuild)
|
||||
{
|
||||
guard self.openMenuRebuildRequests.isCurrent(rebuildToken, for: key) else { return }
|
||||
defer {
|
||||
if self.openMenuRebuildRequests.finish(rebuildToken, for: key) {
|
||||
self.openMenuRebuildTasks.removeValue(forKey: key)
|
||||
self.openMenuRebuildsClosingHostedSubviewMenus.remove(key)
|
||||
}
|
||||
}
|
||||
guard self.openMenus[key] != nil else { return }
|
||||
guard request.beforeRebuild?() ?? true else { return }
|
||||
if request.shouldCloseHostedSubviewMenus {
|
||||
self.closeHostedSubviewMenusForParentSwitch()
|
||||
}
|
||||
self.rebuildOpenMenuIfStillVisible(menu, provider: request.provider)
|
||||
if self.pendingMenuBaselineResyncs.contains(key), !self.menuNeedsRefresh(menu) {
|
||||
self.pendingMenuBaselineResyncs.remove(key)
|
||||
self.resyncMenuAdjunctReadinessBaseline()
|
||||
}
|
||||
}
|
||||
|
||||
private func closeHostedSubviewMenusForParentSwitch() {
|
||||
let hostedMenus = self.openMenus.values.filter { self.isHostedSubviewMenu($0) }
|
||||
for hostedMenu in hostedMenus {
|
||||
hostedMenu.cancelTrackingWithoutAnimation()
|
||||
self.forgetClosedMenu(hostedMenu)
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user