@e-xi/xion 0.0.6

package/dist/renderer/store/index.js

@@ -0,0 +1,595 @@
+// src/shared/renderer-protocol/consts/renderer-protocol-keys.ts
+var RendererProtocolKeys = class {
+  /** 应用渲染根目录主机名 */
+  static root = "root";
+  /** 远程服务代理主机名 */
+  static remoteService = "remote-service";
+};
+
+// src/renderer/store/app/app-store.ts
+import { defineStore } from "pinia";
+import { computed, reactive, ref } from "vue";
+var useXoAppStore = defineStore("useXoAppStore", () => {
+  const initializePromise = ref(null);
+  const loaded = ref(false);
+  const info = reactive({});
+  const rendererProtocol = computed(() => info.rendererProtocol);
+  const rendererProtocolUrls = computed(() => {
+    const scheme = rendererProtocol.value;
+    return {
+      root: scheme ? `${scheme}://${RendererProtocolKeys.root}/` : void 0,
+      remoteService: scheme ? `${scheme}://${RendererProtocolKeys.remoteService}/` : void 0
+    };
+  });
+  const rootUrl = computed(() => rendererProtocolUrls.value.root);
+  const remoteServiceRootUrl = computed(() => rendererProtocolUrls.value.remoteService);
+  function buildRootUrl(pathname = "") {
+    return buildRendererProtocolUrl(rootUrl.value, pathname);
+  }
+  function buildRemoteUrl(pathname = "") {
+    return buildRendererProtocolUrl(remoteServiceRootUrl.value, pathname);
+  }
+  function buildRendererProtocolUrl(rootUrl2, pathname) {
+    if (!rootUrl2) {
+      return void 0;
+    }
+    const normalizedPath = pathname.replace(/^[/\\]+/, "");
+    return new URL(`./${normalizedPath}`, rootUrl2).toString();
+  }
+  async function initialize() {
+    if (loaded.value) {
+      return;
+    }
+    if (initializePromise.value) {
+      return initializePromise.value;
+    }
+    initializePromise.value = (async () => {
+      try {
+        Object.assign(info, await window.xion.app.getInfo());
+        loaded.value = true;
+      } finally {
+        initializePromise.value = null;
+      }
+    })();
+    return initializePromise.value;
+  }
+  return {
+    loaded,
+    info,
+    rendererProtocol,
+    rendererProtocolUrls,
+    rootUrl,
+    remoteServiceRootUrl,
+    buildRootUrl,
+    buildRemoteUrl,
+    initialize
+  };
+});
+
+// src/renderer/store/auth/auth-store.ts
+import { defineStore as defineStore2 } from "pinia";
+import { computed as computed2, ref as ref2, shallowRef } from "vue";
+var useXoAuthStore = defineStore2("useXoAuthStore", () => {
+  const initializePromise = shallowRef();
+  const offState = shallowRef();
+  const status = ref2("initializing");
+  const user = ref2();
+  const error = ref2();
+  const isInitializing = computed2(() => status.value === "initializing");
+  const isAuthenticating = computed2(() => status.value === "authenticating");
+  const isRefreshing = computed2(() => status.value === "refreshing");
+  const isAuthenticated = computed2(() => ["authenticated", "refreshing"].includes(status.value));
+  const isUnauthenticated = computed2(() => status.value === "unauthenticated");
+  const isError = computed2(() => status.value === "error");
+  function applyState(state) {
+    status.value = state.status;
+    user.value = state.user;
+    error.value = state.error;
+  }
+  async function initialize() {
+    if (initializePromise.value) {
+      return initializePromise.value;
+    }
+    if (offState.value && !isError.value) {
+      return;
+    }
+    if (offState.value) {
+      offState.value();
+      offState.value = void 0;
+    }
+    status.value = "initializing";
+    error.value = void 0;
+    initializePromise.value = (async () => {
+      try {
+        offState.value = window.xion.auth.onState((state) => applyState(state));
+        applyState(await window.xion.auth.getState());
+      } catch (cause) {
+        offState.value?.();
+        offState.value = void 0;
+        status.value = "error";
+        error.value = cause instanceof Error ? cause.message : "\u8BA4\u8BC1\u72B6\u6001\u521D\u59CB\u5316\u5931\u8D25";
+      } finally {
+        initializePromise.value = void 0;
+      }
+    })();
+    return initializePromise.value;
+  }
+  async function login(request) {
+    applyState(await window.xion.auth.login(request));
+  }
+  async function logout() {
+    applyState(await window.xion.auth.logout());
+  }
+  return {
+    status,
+    user,
+    error,
+    isInitializing,
+    isAuthenticating,
+    isRefreshing,
+    isAuthenticated,
+    isUnauthenticated,
+    isError,
+    initialize,
+    login,
+    logout
+  };
+});
+
+// src/shared/remote-service/const/remote-service.ts
+var RemoteServiceStatusOptions = [
+  {
+    status: "idle",
+    label: "\u7A7A\u95F2",
+    details: "\u8FDC\u7A0B\u670D\u52A1\u7A7A\u95F2",
+    type: "info"
+  },
+  {
+    status: "connecting",
+    label: "\u8FDE\u63A5\u4E2D",
+    details: "\u8FDC\u7A0B\u670D\u52A1\u8FDE\u63A5\u4E2D",
+    type: "primary"
+  },
+  {
+    status: "connected",
+    label: "\u5DF2\u8FDE\u63A5",
+    details: "\u8FDC\u7A0B\u670D\u52A1\u5DF2\u8FDE\u63A5",
+    type: "success"
+  },
+  {
+    status: "disconnected",
+    label: "\u5DF2\u65AD\u5F00",
+    details: "\u8FDC\u7A0B\u670D\u52A1\u5DF2\u65AD\u5F00",
+    type: "warning"
+  },
+  {
+    status: "error",
+    label: "\u9519\u8BEF",
+    details: "\u8FDC\u7A0B\u670D\u52A1\u8FDE\u63A5\u9519\u8BEF",
+    type: "danger"
+  }
+];
+
+// src/shared/window/consts/window-record-id.ts
+var WindowRecordIDPrefix = "WindowRecord_";
+
+// src/shared/window/consts/window-type-name.ts
+var WindowTypeNamePrefix = "WindowType_";
+
+// src/shared/utils/log-util.ts
+var MaxMessageLength = 16 * 1024;
+var MaxValueLength = 8 * 1024;
+
+// src/shared/utils/window-shared-util.ts
+var WindowSharedUtil = class _WindowSharedUtil {
+  /**
+   * 创建窗口记录 ID
+   * @param {string} id  窗口记录 ID
+   * @returns {XoWindow.RecordID}
+   */
+  static recordId(id) {
+    return id.startsWith(WindowRecordIDPrefix) ? id : `${WindowRecordIDPrefix}${id}`;
+  }
+  /**
+   * 创建窗口类型名称
+   * @param {string} name 窗口类型名称
+   * @returns {XoWindow.TypeName}
+   */
+  static typeName(name) {
+    return name.startsWith(WindowTypeNamePrefix) ? name : `${WindowTypeNamePrefix}${name}`;
+  }
+  /**
+   * 创建窗口标识
+   * @param {string} recordId 窗口记录ID
+   * @param {string} typeName 窗口类型名称
+   * @param {string} url      窗口加载路径
+   * @returns {XoWindow.Identity}
+   */
+  static identity(recordId, typeName, url) {
+    return {
+      // 窗口记录ID
+      recordId: _WindowSharedUtil.recordId(recordId),
+      // 窗口类型名称
+      typeName: _WindowSharedUtil.typeName(typeName),
+      // 窗口加载路径
+      url
+    };
+  }
+};
+
+// src/shared/window/identity/main-window-identity.ts
+var windowTypeName = "main";
+var MainWindowIdentity = WindowSharedUtil.identity("main", windowTypeName, "/index.html");
+
+// src/shared/window/identity/setting-window-identity.ts
+var windowTypeName2 = "setting";
+var SettingWindowIdentity = WindowSharedUtil.identity("setting", windowTypeName2, "/index.html#/settings");
+
+// src/renderer/store/remote-service/remote-service-store.ts
+import { defineStore as defineStore3 } from "pinia";
+import { computed as computed3, reactive as reactive2, ref as ref3 } from "vue";
+var useXoRemoteServiceStore = defineStore3("useXoRemoteServiceStore", () => {
+  const initializePromise = ref3(null);
+  const offState = ref3(null);
+  const offSettings = ref3(null);
+  const status = ref3("idle");
+  const error = ref3();
+  const connectedAt = ref3();
+  const reconnectCount = ref3(0);
+  const settings = ref3();
+  const isIdle = computed3(() => status.value === "idle");
+  const isConnecting = computed3(() => status.value === "connecting");
+  const isConnected = computed3(() => status.value === "connected");
+  const isDisconnected = computed3(() => status.value === "disconnected");
+  const isError = computed3(() => status.value === "error");
+  const statusOption = computed3(() => {
+    return RemoteServiceStatusOptions.find((item) => item.status === status.value) ?? {
+      status: "idle",
+      label: "\u7A7A\u95F2",
+      details: "\u7A7A\u95F2",
+      type: "info"
+    };
+  });
+  function applyState(state) {
+    status.value = state.status;
+    error.value = state.error;
+    connectedAt.value = state.connectedAt;
+    reconnectCount.value = state.reconnectCount;
+  }
+  function applySettings(value) {
+    settings.value = value;
+  }
+  async function initialize() {
+    if (offState.value && offSettings.value) {
+      return;
+    }
+    if (initializePromise.value) {
+      return initializePromise.value;
+    }
+    initializePromise.value = (async () => {
+      try {
+        const [state, remoteSettings] = await Promise.all([
+          window.xion.remoteService.getState(),
+          window.xion.remoteService.getSettings()
+        ]);
+        applyState(state);
+        applySettings(remoteSettings);
+        offState.value = window.xion.remoteService.onState((state2) => applyState(state2));
+        offSettings.value = window.xion.remoteService.onSettings((settings2) => applySettings(settings2));
+      } finally {
+        initializePromise.value = null;
+      }
+    })();
+    return initializePromise.value;
+  }
+  async function setSettings(userSettings) {
+    await window.xion.remoteService.setSettings(userSettings);
+    applySettings(await window.xion.remoteService.getSettings());
+  }
+  async function resetSettings() {
+    await window.xion.remoteService.resetSettings();
+    applySettings(await window.xion.remoteService.getSettings());
+  }
+  function getButtonStatus(options) {
+    return reactive2({
+      name: "\u8FDC\u7A0B\u670D\u52A1",
+      icon: "xion-icon-server-connect",
+      redirect: {
+        windowIdentity: SettingWindowIdentity,
+        routeName: void 0
+      },
+      ...options,
+      tooltip: statusOption.value.details,
+      type: statusOption.value.type
+    });
+  }
+  return {
+    status,
+    error,
+    connectedAt,
+    reconnectCount,
+    settings,
+    statusOption,
+    isIdle,
+    isConnecting,
+    isConnected,
+    isDisconnected,
+    isError,
+    initialize,
+    setSettings,
+    resetSettings,
+    getButtonStatus
+  };
+});
+
+// src/renderer/store/theme/theme-store.ts
+import { defineStore as defineStore4 } from "pinia";
+import { computed as computed4, ref as ref4 } from "vue";
+var useXoThemeStore = defineStore4("useXoThemeStore", () => {
+  const initializePromise = ref4(null);
+  const offUpdated = ref4(null);
+  const themeSource = ref4("system");
+  const shouldUseDarkColors = ref4(false);
+  const shouldUseLightColors = computed4(() => !shouldUseDarkColors.value);
+  const titleBarOverlayEnabled = ref4(false);
+  const titleBarOverlay = ref4({});
+  function applyState(state) {
+    themeSource.value = state.themeSource;
+    shouldUseDarkColors.value = state.shouldUseDarkColors;
+    titleBarOverlayEnabled.value = state.titleBarOverlayEnabled;
+    titleBarOverlay.value = state.titleBarOverlay;
+    applyDocumentTheme(state.shouldUseDarkColors);
+    applyDocumentTitleBarVariables(state.titleBarOverlay, state.titleBarOverlayBackground);
+  }
+  function applyDocumentTheme(isDark) {
+    document.documentElement.classList.toggle("dark", isDark);
+  }
+  function applyDocumentTitleBarVariables(titleBarOverlay2, titleBarOverlayBackground) {
+    const height = titleBarOverlay2?.height;
+    const varHeight = "--xo-global-title-bar-height";
+    if (height === void 0) {
+      document.documentElement.style.removeProperty(varHeight);
+    } else {
+      document.documentElement.style.setProperty(varHeight, `${height}px`);
+    }
+    const background = titleBarOverlayBackground ?? titleBarOverlay2?.color;
+    const varBackground = "--xo-global-title-bar-background";
+    if (background === void 0) {
+      document.documentElement.style.removeProperty(varBackground);
+    } else {
+      document.documentElement.style.setProperty(varBackground, background);
+    }
+    const color = titleBarOverlay2?.symbolColor;
+    const varColor = "--xo-global-title-bar-color";
+    if (color === void 0) {
+      document.documentElement.style.removeProperty(varColor);
+    } else {
+      document.documentElement.style.setProperty(varColor, color);
+    }
+    window.xionTitleBar ??= { height: 0, background: "", color: "" };
+    Object.assign(window.xionTitleBar, {
+      height: height ?? 0,
+      background: background ?? "",
+      color: color ?? ""
+    });
+  }
+  async function initialize() {
+    if (offUpdated.value) {
+      return;
+    }
+    if (initializePromise.value) {
+      return initializePromise.value;
+    }
+    initializePromise.value = (async () => {
+      try {
+        applyState(await window.xion.theme.getState());
+        offUpdated.value = window.xion.theme.onUpdated((state) => applyState(state));
+      } finally {
+        initializePromise.value = null;
+      }
+    })();
+    return initializePromise.value;
+  }
+  async function setSource(source) {
+    await window.xion.theme.setSource(source);
+    applyState(await window.xion.theme.getState());
+  }
+  return {
+    themeSource,
+    shouldUseDarkColors,
+    shouldUseLightColors,
+    titleBarOverlay,
+    titleBarOverlayEnabled,
+    initialize,
+    setSource
+  };
+});
+
+// src/renderer/store/updater/updater-store.ts
+import { defineStore as defineStore5 } from "pinia";
+import { computed as computed5, ref as ref5 } from "vue";
+var useXoUpdaterStore = defineStore5("useXoUpdaterStore", () => {
+  const initializePromise = ref5(null);
+  const offState = ref5(null);
+  const offSettings = ref5(null);
+  const status = ref5("idle");
+  const updateInfo = ref5();
+  const progress = ref5();
+  const formattedProgress = ref5();
+  const error = ref5();
+  const settings = ref5();
+  const downloadCancellationCount = ref5(0);
+  const disabledUntilRestart = ref5(false);
+  const isIdle = computed5(() => status.value === "idle");
+  const isChecking = computed5(() => status.value === "checking");
+  const isAvailable = computed5(() => status.value === "available");
+  const isNotAvailable = computed5(() => status.value === "not-available");
+  const isDownloading = computed5(() => status.value === "downloading");
+  const isCancelling = computed5(() => status.value === "cancelling");
+  const isDownloaded = computed5(() => status.value === "downloaded");
+  const isError = computed5(() => status.value === "error");
+  const version = computed5(() => updateInfo.value?.version);
+  const releaseName = computed5(() => updateInfo.value?.releaseName);
+  const releaseNotes = computed5(() => updateInfo.value?.releaseNotes);
+  const releaseDate = computed5(() => updateInfo.value?.releaseDate);
+  function applyState(state) {
+    status.value = state.status;
+    updateInfo.value = state.updateInfo;
+    progress.value = state.progress;
+    formattedProgress.value = state.formattedProgress;
+    error.value = state.error;
+    downloadCancellationCount.value = state.downloadCancellationCount;
+    disabledUntilRestart.value = state.disabledUntilRestart;
+  }
+  function applySettings(value) {
+    settings.value = value;
+  }
+  async function initialize() {
+    if (offState.value && offSettings.value) {
+      return;
+    }
+    if (initializePromise.value) {
+      return initializePromise.value;
+    }
+    initializePromise.value = (async () => {
+      try {
+        const [state, settings2] = await Promise.all([
+          window.xion.updater.getState(),
+          window.xion.updater.getSettings()
+        ]);
+        applyState(state);
+        applySettings(settings2);
+        offState.value = window.xion.updater.onState((state2) => applyState(state2));
+        offSettings.value = window.xion.updater.onSettings((settings3) => applySettings(settings3));
+      } finally {
+        initializePromise.value = null;
+      }
+    })();
+    return initializePromise.value;
+  }
+  async function checkForUpdates() {
+    await window.xion.updater.checkForUpdates();
+  }
+  async function downloadUpdate() {
+    await window.xion.updater.downloadUpdate();
+  }
+  async function cancelDownload() {
+    return window.xion.updater.cancelDownload();
+  }
+  async function quitAndInstall() {
+    await window.xion.updater.quitAndInstall();
+  }
+  async function saveSettings(userSettings) {
+    await window.xion.updater.setSettings(userSettings);
+    applySettings(await window.xion.updater.getSettings());
+  }
+  async function resetSettings() {
+    await window.xion.updater.resetSettings();
+    applySettings(await window.xion.updater.getSettings());
+  }
+  return {
+    status,
+    updateInfo,
+    progress,
+    formattedProgress,
+    error,
+    settings,
+    downloadCancellationCount,
+    disabledUntilRestart,
+    isIdle,
+    isChecking,
+    isAvailable,
+    isNotAvailable,
+    isDownloading,
+    isCancelling,
+    isDownloaded,
+    isError,
+    version,
+    releaseName,
+    releaseNotes,
+    releaseDate,
+    initialize,
+    checkForUpdates,
+    downloadUpdate,
+    cancelDownload,
+    quitAndInstall,
+    saveSettings,
+    resetSettings
+  };
+});
+
+// src/renderer/store/window/window-store.ts
+import { defineStore as defineStore6 } from "pinia";
+import { reactive as reactive3, ref as ref6 } from "vue";
+function defaultState() {
+  return {
+    windowMaterial: void 0,
+    isSidebarFolded: false,
+    isAlwaysOnTop: false,
+    isMaximized: false,
+    isFullScreen: false,
+    isMinimized: false,
+    isFullScreenable: false,
+    isMinimizable: false,
+    isMaximizable: false,
+    isClosable: false
+  };
+}
+var useXoWindowStore = defineStore6("useXoWindowStore", () => {
+  const initializePromise = ref6(null);
+  const offState = ref6(null);
+  const loaded = ref6(false);
+  const state = reactive3(defaultState());
+  function applyState(nextState) {
+    Object.assign(state, nextState);
+    applyDocumentWindowMaterial(state.windowMaterial);
+  }
+  function applyDocumentWindowMaterial(windowMaterial) {
+    const documentElement = document.documentElement;
+    if (windowMaterial === void 0) {
+      delete documentElement.dataset.material;
+    } else {
+      documentElement.dataset.material = windowMaterial;
+    }
+  }
+  async function initialize() {
+    if (offState.value) {
+      return;
+    }
+    if (initializePromise.value) {
+      return initializePromise.value;
+    }
+    initializePromise.value = (async () => {
+      try {
+        applyState(await window.xion.window.getState());
+        offState.value = window.xion.window.onState(applyState);
+        loaded.value = true;
+      } finally {
+        initializePromise.value = null;
+      }
+    })();
+    return initializePromise.value;
+  }
+  async function toggleSidebarFold() {
+    await window.xion.window.toggleSidebarFold();
+  }
+  async function toggleAlwaysOnTop() {
+    await window.xion.window.toggleAlwaysOnTop();
+  }
+  return {
+    loaded,
+    state,
+    applyState,
+    initialize,
+    toggleSidebarFold,
+    toggleAlwaysOnTop
+  };
+});
+export {
+  useXoAppStore,
+  useXoAuthStore,
+  useXoRemoteServiceStore,
+  useXoThemeStore,
+  useXoUpdaterStore,
+  useXoWindowStore
+};

package/dist/renderer/store/remote-service/remote-service-store.d.ts

@@ -0,0 +1,52 @@
+/**
+ * 远程服务 Store
+ */
+export declare const useXoRemoteServiceStore: import("pinia").StoreDefinition<"useXoRemoteServiceStore", Pick<{
+    status: import("vue").Ref<"error" | "idle" | "connecting" | "connected" | "disconnected", "error" | "idle" | "connecting" | "connected" | "disconnected">;
+    error: import("vue").Ref<string | undefined, string | undefined>;
+    connectedAt: import("vue").Ref<number | undefined, number | undefined>;
+    reconnectCount: import("vue").Ref<number, number>;
+    settings: import("vue").Ref<XoRemoteService.EffectiveSettings | undefined, XoRemoteService.EffectiveSettings | undefined>;
+    statusOption: import("vue").ComputedRef<XoRemoteService.StatusOption>;
+    isIdle: import("vue").ComputedRef<boolean>;
+    isConnecting: import("vue").ComputedRef<boolean>;
+    isConnected: import("vue").ComputedRef<boolean>;
+    isDisconnected: import("vue").ComputedRef<boolean>;
+    isError: import("vue").ComputedRef<boolean>;
+    initialize: () => Promise<void>;
+    setSettings: (userSettings: XoRemoteService.UserSettings) => Promise<void>;
+    resetSettings: () => Promise<void>;
+    getButtonStatus: (options?: XoComponent.ServiceStatusBarStatusButtonOption) => XoComponent.ServiceStatusBarStatusOption;
+}, "error" | "status" | "connectedAt" | "reconnectCount" | "settings">, Pick<{
+    status: import("vue").Ref<"error" | "idle" | "connecting" | "connected" | "disconnected", "error" | "idle" | "connecting" | "connected" | "disconnected">;
+    error: import("vue").Ref<string | undefined, string | undefined>;
+    connectedAt: import("vue").Ref<number | undefined, number | undefined>;
+    reconnectCount: import("vue").Ref<number, number>;
+    settings: import("vue").Ref<XoRemoteService.EffectiveSettings | undefined, XoRemoteService.EffectiveSettings | undefined>;
+    statusOption: import("vue").ComputedRef<XoRemoteService.StatusOption>;
+    isIdle: import("vue").ComputedRef<boolean>;
+    isConnecting: import("vue").ComputedRef<boolean>;
+    isConnected: import("vue").ComputedRef<boolean>;
+    isDisconnected: import("vue").ComputedRef<boolean>;
+    isError: import("vue").ComputedRef<boolean>;
+    initialize: () => Promise<void>;
+    setSettings: (userSettings: XoRemoteService.UserSettings) => Promise<void>;
+    resetSettings: () => Promise<void>;
+    getButtonStatus: (options?: XoComponent.ServiceStatusBarStatusButtonOption) => XoComponent.ServiceStatusBarStatusOption;
+}, "isError" | "statusOption" | "isIdle" | "isConnecting" | "isConnected" | "isDisconnected">, Pick<{
+    status: import("vue").Ref<"error" | "idle" | "connecting" | "connected" | "disconnected", "error" | "idle" | "connecting" | "connected" | "disconnected">;
+    error: import("vue").Ref<string | undefined, string | undefined>;
+    connectedAt: import("vue").Ref<number | undefined, number | undefined>;
+    reconnectCount: import("vue").Ref<number, number>;
+    settings: import("vue").Ref<XoRemoteService.EffectiveSettings | undefined, XoRemoteService.EffectiveSettings | undefined>;
+    statusOption: import("vue").ComputedRef<XoRemoteService.StatusOption>;
+    isIdle: import("vue").ComputedRef<boolean>;
+    isConnecting: import("vue").ComputedRef<boolean>;
+    isConnected: import("vue").ComputedRef<boolean>;
+    isDisconnected: import("vue").ComputedRef<boolean>;
+    isError: import("vue").ComputedRef<boolean>;
+    initialize: () => Promise<void>;
+    setSettings: (userSettings: XoRemoteService.UserSettings) => Promise<void>;
+    resetSettings: () => Promise<void>;
+    getButtonStatus: (options?: XoComponent.ServiceStatusBarStatusButtonOption) => XoComponent.ServiceStatusBarStatusOption;
+}, "setSettings" | "resetSettings" | "initialize" | "getButtonStatus">>;

package/dist/renderer/store/theme/theme-store.d.ts

@@ -0,0 +1,52 @@
+/**
+ * 主题 Store
+ */
+export declare const useXoThemeStore: import("pinia").StoreDefinition<"useXoThemeStore", Pick<{
+    themeSource: import("vue").Ref<"light" | "dark" | "system", "light" | "dark" | "system">;
+    shouldUseDarkColors: import("vue").Ref<boolean, boolean>;
+    shouldUseLightColors: import("vue").ComputedRef<boolean>;
+    titleBarOverlay: import("vue").Ref<{
+        color?: string | undefined;
+        symbolColor?: string | undefined;
+        height?: number | undefined;
+    }, Electron.TitleBarOverlayOptions | {
+        color?: string | undefined;
+        symbolColor?: string | undefined;
+        height?: number | undefined;
+    }>;
+    titleBarOverlayEnabled: import("vue").Ref<boolean, boolean>;
+    initialize: () => Promise<void>;
+    setSource: (source: XoTheme.Source) => Promise<void>;
+}, "themeSource" | "titleBarOverlay" | "shouldUseDarkColors" | "titleBarOverlayEnabled">, Pick<{
+    themeSource: import("vue").Ref<"light" | "dark" | "system", "light" | "dark" | "system">;
+    shouldUseDarkColors: import("vue").Ref<boolean, boolean>;
+    shouldUseLightColors: import("vue").ComputedRef<boolean>;
+    titleBarOverlay: import("vue").Ref<{
+        color?: string | undefined;
+        symbolColor?: string | undefined;
+        height?: number | undefined;
+    }, Electron.TitleBarOverlayOptions | {
+        color?: string | undefined;
+        symbolColor?: string | undefined;
+        height?: number | undefined;
+    }>;
+    titleBarOverlayEnabled: import("vue").Ref<boolean, boolean>;
+    initialize: () => Promise<void>;
+    setSource: (source: XoTheme.Source) => Promise<void>;
+}, "shouldUseLightColors">, Pick<{
+    themeSource: import("vue").Ref<"light" | "dark" | "system", "light" | "dark" | "system">;
+    shouldUseDarkColors: import("vue").Ref<boolean, boolean>;
+    shouldUseLightColors: import("vue").ComputedRef<boolean>;
+    titleBarOverlay: import("vue").Ref<{
+        color?: string | undefined;
+        symbolColor?: string | undefined;
+        height?: number | undefined;
+    }, Electron.TitleBarOverlayOptions | {
+        color?: string | undefined;
+        symbolColor?: string | undefined;
+        height?: number | undefined;
+    }>;
+    titleBarOverlayEnabled: import("vue").Ref<boolean, boolean>;
+    initialize: () => Promise<void>;
+    setSource: (source: XoTheme.Source) => Promise<void>;
+}, "setSource" | "initialize">>;