@owdproject/nuxt 0.0.0-stage → 4.0.0-alpha.3

package/dist/runtime/internal/controllers/WindowController.js

@@ -0,0 +1,435 @@
+import { markRaw, reactive, shallowRef, defineAsyncComponent } from "vue";
+import { createActor } from "xstate";
+import {
+  windowMachine,
+  IframeGuard
+} from "@owdproject/core";
+function formatWindowSnapshotValue(value) {
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length > 0) {
+      const [k, v] = entries[0];
+      return `${k}.${formatWindowSnapshotValue(v)}`;
+    }
+  }
+  return "normal";
+}
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  return JSON.parse(JSON.stringify(obj));
+}
+export class WindowController {
+  application;
+  instanced = true;
+  model;
+  _stateValue = shallowRef("normal.focused.idle");
+  get stateValue() {
+    return this._stateValue.value;
+  }
+  config = {
+    title: "",
+    category: "",
+    component: void 0,
+    position: { x: 0, y: 0, z: 0 },
+    size: { width: void 0, height: void 0 },
+    minimizable: true,
+    maximized: false,
+    maximizable: true,
+    destroyable: true,
+    draggable: true,
+    resizable: true
+  };
+  override = reactive({});
+  storedState;
+  windowActor;
+  isDisposed = false;
+  actions;
+  constructor(application, model, windowConfig, windowStoredState, options) {
+    this.application = application;
+    this.model = model;
+    this.storedState = windowStoredState;
+    this.setConfig(windowConfig);
+    this.restoreState();
+    this.actions = Object.freeze({
+      setActive: this.setActive.bind(this),
+      setFocus: this.setFocus.bind(this),
+      bringToFront: this.focus.bind(this),
+      focus: this.focus.bind(this),
+      setPosition: this.setPosition.bind(this),
+      startDrag: this.startDrag.bind(this),
+      stopDrag: this.stopDrag.bind(this),
+      startResize: this.startResize.bind(this),
+      stopResize: this.stopResize.bind(this),
+      setSize: this.setSize.bind(this),
+      minimize: this.minimize.bind(this),
+      unminimize: this.unminimize.bind(this),
+      toggleMinimize: this.toggleMinimize.bind(this),
+      toggleMaximize: this.toggleMaximize.bind(this),
+      maximize: this.maximize.bind(this),
+      unmaximize: this.unmaximize.bind(this),
+      setLayout: this.setLayout.bind(this),
+      clearLayout: this.clearLayout.bind(this),
+      saveBoundsBeforeLayout: this.saveBoundsBeforeLayout.bind(this),
+      destroy: this.destroy.bind(this),
+      setWorkspace: this.setWorkspace.bind(this),
+      setTitleOverride: this.setTitleOverride.bind(this),
+      resetTitleOverride: this.resetTitleOverride.bind(this),
+      setWindowTitleOverride: this.setWindowTitleOverride.bind(this),
+      resetWindowTitleOverride: this.resetWindowTitleOverride.bind(this)
+    });
+    let initialValue = { normal: "unfocused" };
+    if (this.state.active === false) {
+      initialValue = "minimized";
+    } else if (this.state.maximized === true) {
+      initialValue = this.state.focused ? { maximized: "focused" } : { maximized: "unfocused" };
+    } else if (this.state.focused === true) {
+      initialValue = { normal: { focused: "idle" } };
+    }
+    this.windowActor = createActor(windowMachine, {
+      state: windowMachine.resolveState({
+        value: initialValue,
+        context: {
+          wasMaximized: !!this.state.maximized,
+          config: this.config
+        }
+      })
+    });
+    let wasLastMaximized = !!this.state.maximized;
+    this.windowActor.subscribe((snapshot) => {
+      if (this.isDisposed) return;
+      this._stateValue.value = formatWindowSnapshotValue(snapshot.value);
+      const isMinimized = snapshot.matches("minimized");
+      const isMaximized = snapshot.matches("maximized");
+      const isFocused = snapshot.matches("normal.focused") || snapshot.matches("maximized.focused");
+      const isDragging = snapshot.matches("normal.focused.dragging");
+      const isResizing = snapshot.matches("normal.focused.resizing");
+      if (this.state.active !== !isMinimized) this.state.active = !isMinimized;
+      if (this.state.maximized !== isMaximized) this.state.maximized = isMaximized;
+      if (this.state.focused !== isFocused) this.state.focused = isFocused;
+      if (this.state.dragging !== isDragging) this.state.dragging = isDragging;
+      if (this.state.resizing !== isResizing) this.state.resizing = isResizing;
+      if (isMaximized && !wasLastMaximized) {
+        this.saveBoundsBeforeLayout();
+        this.state.layout = "maximize";
+        const workarea = options?.getWorkarea?.();
+        if (workarea && workarea.width > 0 && workarea.height > 0) {
+          this.setPosition({ x: workarea.x, y: workarea.y });
+          this.setSize({ width: workarea.width, height: workarea.height });
+        }
+      } else if (!isMaximized && wasLastMaximized) {
+        if (this.state.layout === "maximize") {
+          this.clearLayout();
+        }
+      }
+      wasLastMaximized = isMaximized;
+    });
+    this.windowActor.start();
+  }
+  setConfig(config) {
+    if (config.component) {
+      this.config.component = markRaw(
+        typeof config.component === "function" ? defineAsyncComponent(config.component) : config.component
+      );
+    }
+    if (config.title) this.config.title = config.title;
+    if (config.icon) this.config.icon = config.icon;
+    if (!this.config.position) this.config.position = { x: 0, y: 0, z: 0 };
+    if (config.position?.x !== void 0) this.config.position.x = config.position.x;
+    if (config.position?.y !== void 0) this.config.position.y = config.position.y;
+    if (config.position?.z !== void 0) this.config.position.z = config.position.z;
+    if (config.size?.width !== void 0) this.config.size.width = config.size.width;
+    if (config.size?.height !== void 0) this.config.size.height = config.size.height;
+    if (config.size?.minWidth !== void 0) this.config.size.minWidth = config.size.minWidth;
+    if (config.size?.minHeight !== void 0) this.config.size.minHeight = config.size.minHeight;
+    if (config.size?.maxWidth !== void 0) this.config.size.maxWidth = config.size.maxWidth;
+    if (config.size?.maxHeight !== void 0) this.config.size.maxHeight = config.size.maxHeight;
+    if (typeof config.resizable !== "undefined") this.config.resizable = config.resizable;
+    if (typeof config.minimizable !== "undefined") this.config.minimizable = config.minimizable;
+    if (typeof config.maximizable !== "undefined") {
+      this.config.maximizable = config.maximizable;
+    } else {
+      this.config.maximizable = this.config.resizable !== false;
+    }
+    if (typeof config.maximized !== "undefined") this.config.maximized = config.maximized;
+    if (typeof config.draggable !== "undefined") this.config.draggable = config.draggable;
+    if (typeof config.destroyable !== "undefined") this.config.destroyable = config.destroyable;
+    const DEFAULT_OVERRIDABLE = {
+      draggable: true,
+      resizable: false,
+      position: false,
+      size: false,
+      maximized: false,
+      destroyable: false,
+      minimizable: false,
+      maximizable: false
+    };
+    DEFAULT_OVERRIDABLE.position = DEFAULT_OVERRIDABLE.draggable;
+    DEFAULT_OVERRIDABLE.size = DEFAULT_OVERRIDABLE.resizable;
+    DEFAULT_OVERRIDABLE.maximized = DEFAULT_OVERRIDABLE.maximizable;
+    this.config.overridable = {
+      ...DEFAULT_OVERRIDABLE,
+      ...config.overridable || {}
+    };
+  }
+  get state() {
+    return this.storedState.state;
+  }
+  restoreState() {
+    const overridable = this.config.overridable || {};
+    for (const key in overridable) {
+      if (overridable[key]) {
+        const stateKey = key;
+        if (typeof this.state[stateKey] === "undefined") {
+          if (typeof this.config[stateKey] === "object") {
+            this.state[stateKey] = deepClone(this.config[stateKey]);
+          } else {
+            this.state[stateKey] = !!this.config[stateKey];
+          }
+        }
+      }
+    }
+  }
+  get meta() {
+    return this.storedState.meta;
+  }
+  setPosition(data) {
+    if (!this.state.position) {
+      this.state.position = { x: 0, y: 0 };
+    }
+    this.state.position.x = Math.round(data.x);
+    this.state.position.y = Math.round(data.y);
+  }
+  setActive(value) {
+    if (this.isDisposed) return;
+    if (value) {
+      this.windowActor.send({ type: "RESTORE" });
+    } else {
+      this.windowActor.send({ type: "MINIMIZE" });
+    }
+  }
+  setFocus(value) {
+    if (this.isDisposed) return;
+    if (value) {
+      if (!this.state.focused) {
+        this.windowActor.send({ type: "FOCUS" });
+      }
+    } else {
+      if (this.state.focused) {
+        this.windowActor.send({ type: "BLUR" });
+      }
+    }
+  }
+  focus() {
+    if (this.isDisposed) return;
+    if (!this.state.position) {
+      this.state.position = { x: 0, y: 0, z: 0 };
+    }
+    if (this.application?.focusWindow) {
+      this.application.focusWindow(this);
+    } else {
+      this.setFocus(true);
+    }
+  }
+  get title() {
+    if (typeof this.override.title !== "undefined") return this.override.title;
+    if (this.config.title) return this.config.title;
+    return this.application?.config?.title ?? "";
+  }
+  get windowTitle() {
+    if (typeof this.override.windowTitle !== "undefined") return this.override.windowTitle;
+    return this.title;
+  }
+  get icon() {
+    if (typeof this.override.icon !== "undefined") return this.override.icon;
+    if (this.config.icon) return this.config.icon;
+    return this.application?.config?.icon;
+  }
+  get position() {
+    return this.state.position ?? this.config.position;
+  }
+  get size() {
+    const stateSize = this.state.size || {};
+    const configSize = this.config.size || {};
+    return {
+      width: stateSize.width !== void 0 ? stateSize.width : configSize.width,
+      height: stateSize.height !== void 0 ? stateSize.height : configSize.height,
+      minWidth: stateSize.minWidth !== void 0 ? stateSize.minWidth : configSize.minWidth,
+      maxWidth: stateSize.maxWidth !== void 0 ? stateSize.maxWidth : configSize.maxWidth,
+      minHeight: stateSize.minHeight !== void 0 ? stateSize.minHeight : configSize.minHeight,
+      maxHeight: stateSize.maxHeight !== void 0 ? stateSize.maxHeight : configSize.maxHeight
+    };
+  }
+  setSize(data) {
+    if (!this.state.size) {
+      this.state.size = { width: void 0, height: void 0 };
+    }
+    this.state.size.width = Math.round(data.width);
+    this.state.size.height = Math.round(data.height);
+  }
+  get isMinimizable() {
+    return this.config.overridable?.minimizable ? !!this.state.minimizable : !!this.config.minimizable;
+  }
+  minimize() {
+    if (this.isDisposed || !this.isMinimizable) return false;
+    this.windowActor.send({ type: "MINIMIZE" });
+    return true;
+  }
+  unminimize() {
+    if (this.isDisposed) return false;
+    this.windowActor.send({ type: "RESTORE" });
+    return true;
+  }
+  toggleMinimize() {
+    if (this.isDisposed) return;
+    if (this.windowActor.getSnapshot().matches("minimized")) {
+      this.unminimize();
+      this.focus();
+    } else if (this.state.focused) {
+      this.minimize();
+    } else {
+      this.focus();
+    }
+  }
+  get isMaximizable() {
+    return this.state.maximizable !== void 0 ? !!this.state.maximizable : !!this.config.maximizable;
+  }
+  get isMaximized() {
+    if (this.state.layout === "maximize") return true;
+    return this.config.overridable?.maximized ? !!this.state.maximized : !!this.config.maximized;
+  }
+  parseSizeValue(value, fallback) {
+    if (typeof value === "number") return value;
+    if (typeof value === "string") {
+      const parsed = Number.parseFloat(value);
+      if (!Number.isNaN(parsed)) return parsed;
+    }
+    return fallback;
+  }
+  saveBoundsBeforeLayout() {
+    if (this.state.layout && this.state.layout !== "normal") return;
+    const pos = this.position;
+    const size = this.size;
+    this.state.boundsBeforeLayout = {
+      x: pos?.x ?? 0,
+      y: pos?.y ?? 0,
+      width: this.parseSizeValue(size.width, 420),
+      height: this.parseSizeValue(size.height, 320)
+    };
+  }
+  setLayout(layout) {
+    if (this.isDisposed) return false;
+    if (layout === "normal") {
+      this.windowActor.send({ type: "RESTORE" });
+      this.clearLayout();
+      return true;
+    }
+    if (!this.isMaximizable) return false;
+    if (layout === "maximize") {
+      this.windowActor.send({ type: "MAXIMIZE" });
+    } else {
+      this.windowActor.send({ type: "RESTORE" });
+      this.saveBoundsBeforeLayout();
+      this.state.layout = layout;
+    }
+    return true;
+  }
+  clearLayout() {
+    const bounds = this.state.boundsBeforeLayout;
+    if (bounds) {
+      this.setPosition({ x: bounds.x, y: bounds.y });
+      this.setSize({ width: bounds.width, height: bounds.height });
+      delete this.state.boundsBeforeLayout;
+    }
+    this.state.layout = "normal";
+    this.state.maximized = false;
+    return true;
+  }
+  toggleMaximize() {
+    if (this.isDisposed || !this.isMaximizable) return false;
+    if (this.isMaximized) {
+      this.windowActor.send({ type: "RESTORE" });
+    } else {
+      this.windowActor.send({ type: "MAXIMIZE" });
+    }
+    return true;
+  }
+  maximize() {
+    if (this.isDisposed || !this.isMaximizable) return false;
+    this.windowActor.send({ type: "MAXIMIZE" });
+    return true;
+  }
+  unmaximize() {
+    if (this.isDisposed || !this.isMaximizable) return false;
+    this.windowActor.send({ type: "RESTORE" });
+    return true;
+  }
+  get isDestroyable() {
+    return this.config.overridable?.destroyable ? !!this.state.destroyable : !!this.config.destroyable;
+  }
+  dispose() {
+    if (this.isDisposed) return;
+    this.isDisposed = true;
+    try {
+      this.windowActor.stop();
+    } catch {
+    }
+  }
+  destroy() {
+    if (!this.isDestroyable) return false;
+    if (!this.isDisposed) {
+      this.windowActor.send({ type: "DESTROY" });
+    }
+    this.application?.closeWindow?.(this.state.id);
+    return true;
+  }
+  get isDraggable() {
+    return this.config.overridable?.draggable ? !!this.state.draggable : !!this.config.draggable;
+  }
+  get isResizable() {
+    return this.config.overridable?.resizable ? !!this.state.resizable : !!this.config.resizable;
+  }
+  setWorkspace(workspaceId) {
+    this.state.workspace = workspaceId;
+  }
+  startDrag() {
+    if (!this.isDisposed) {
+      IframeGuard.enable();
+      this.windowActor.send({ type: "DRAG_START" });
+    }
+  }
+  stopDrag() {
+    if (!this.isDisposed) {
+      IframeGuard.disable();
+      this.windowActor.send({ type: "DRAG_END" });
+    }
+  }
+  startResize() {
+    if (!this.isDisposed) {
+      IframeGuard.enable();
+      this.windowActor.send({ type: "RESIZE_START" });
+    }
+  }
+  stopResize() {
+    if (!this.isDisposed) {
+      IframeGuard.disable();
+      this.windowActor.send({ type: "RESIZE_END" });
+    }
+  }
+  setTitleOverride(value) {
+    this.override.title = value;
+  }
+  resetTitleOverride() {
+    this.override.title = void 0;
+  }
+  setWindowTitleOverride(value) {
+    this.override.windowTitle = value;
+  }
+  resetWindowTitleOverride() {
+    this.override.windowTitle = void 0;
+  }
+  menu = [];
+  setMenu(menu) {
+    this.menu = menu;
+  }
+}

package/dist/runtime/plugins/01.desktop-shell-init.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/01.desktop-shell-init.client.js

@@ -0,0 +1,18 @@
+import { defineNuxtPlugin } from "nuxt/app";
+import { useDesktopStore } from "../stores/storeDesktop.js";
+import { useDesktopWorkspaceStore } from "../stores/storeDesktopWorkspace.js";
+import { useDesktopVolumeStore } from "../stores/storeDesktopVolume.js";
+import { useDesktopNotificationStore } from "../stores/storeNotification.js";
+import { useDesktopTrayStore } from "../stores/storeDesktopTray.js";
+export default defineNuxtPlugin({
+  name: "desktop-shell-init",
+  dependsOn: ["pinia"],
+  setup() {
+    if (import.meta.server) return;
+    useDesktopStore();
+    useDesktopWorkspaceStore();
+    useDesktopVolumeStore();
+    useDesktopNotificationStore();
+    useDesktopTrayStore();
+  }
+});

package/dist/runtime/plugins/02.desktop-register-desktop-apps.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/02.desktop-register-desktop-apps.client.js

@@ -0,0 +1,7 @@
+import { defineNuxtPlugin } from "nuxt/app";
+export default defineNuxtPlugin({
+  name: "desktop-register-desktop-apps",
+  dependsOn: ["pinia", "desktop-shell-init"],
+  setup() {
+  }
+});

package/dist/runtime/stores/storeApplicationMeta.d.ts

@@ -0,0 +1,2 @@
+export declare function applicationMetaStoreId(appId: string): string;
+export declare function useApplicationMetaStore(appId: string, customSetup?: () => Record<string, any>): import("pinia").SetupStoreDefinition<string, unknown>;

package/dist/runtime/stores/storeApplicationMeta.js

@@ -0,0 +1,20 @@
+import { reactive } from "vue";
+import { defineStore } from "pinia";
+const metaStoreRegistry = /* @__PURE__ */ new Map();
+export function applicationMetaStoreId(appId) {
+  return `desktop/application/${appId}/meta`;
+}
+export function useApplicationMetaStore(appId, customSetup) {
+  let storeFactory = metaStoreRegistry.get(appId);
+  if (!storeFactory) {
+    storeFactory = defineStore(applicationMetaStoreId(appId), () => {
+      if (customSetup) {
+        return customSetup();
+      }
+      const data = reactive({});
+      return { data };
+    });
+    metaStoreRegistry.set(appId, storeFactory);
+  }
+  return storeFactory;
+}

package/dist/runtime/stores/storeApplicationWindows.d.ts

@@ -0,0 +1,2 @@
+export declare function applicationWindowsStoreId(appId: string): string;
+export declare function useApplicationWindowsStore(appId: string): import("pinia").Store<string, Pick<unknown, never>, Pick<unknown, never>, Pick<unknown, never>>;

package/dist/runtime/stores/storeApplicationWindows.js

@@ -0,0 +1,33 @@
+import { reactive } from "vue";
+import { defineStore } from "pinia";
+const windowsStoreRegistry = /* @__PURE__ */ new Map();
+export function applicationWindowsStoreId(appId) {
+  return `desktop/application/${appId}/windows`;
+}
+export function useApplicationWindowsStore(appId) {
+  let storeFactory = windowsStoreRegistry.get(appId);
+  if (!storeFactory) {
+    storeFactory = defineStore(applicationWindowsStoreId(appId), () => {
+      const windows = reactive({});
+      function setWindowState(windowId, stored) {
+        windows[windowId] = stored;
+      }
+      function removeWindowState(windowId) {
+        delete windows[windowId];
+      }
+      function clearWindows() {
+        for (const key of Object.keys(windows)) {
+          delete windows[key];
+        }
+      }
+      return {
+        windows,
+        setWindowState,
+        removeWindowState,
+        clearWindows
+      };
+    });
+    windowsStoreRegistry.set(appId, storeFactory);
+  }
+  return storeFactory();
+}

package/dist/runtime/stores/storeDesktop.d.ts

@@ -0,0 +1,17 @@
+export interface DesktopGlobalState {
+    defaultApps: Record<string, {
+        applicationId: string;
+        entry: string;
+    }>;
+    positionZ: number;
+}
+export declare const useDesktopStore: import("pinia").SetupStoreDefinition<"desktop", {
+    state: {
+        defaultApps: Record<string, {
+            applicationId: string;
+            entry: string;
+        }>;
+        positionZ: number;
+    };
+    incrementPositionZ: () => number;
+}>;

package/dist/runtime/stores/storeDesktop.js

@@ -0,0 +1,16 @@
+import { reactive } from "vue";
+import { defineStore } from "pinia";
+export const useDesktopStore = defineStore("desktop", () => {
+  const state = reactive({
+    defaultApps: {},
+    positionZ: 100
+  });
+  function incrementPositionZ() {
+    state.positionZ += 1;
+    return state.positionZ;
+  }
+  return {
+    state,
+    incrementPositionZ
+  };
+});

package/dist/runtime/stores/storeDesktopDefaultApps.d.ts

@@ -0,0 +1,8 @@
+import type { IApplicationController } from '../../types/index.js';
+export declare const useDesktopDefaultAppsStore: import("pinia").SetupStoreDefinition<"desktop/default-apps", {
+    getDefaultApp: (feature: string) => {
+        applicationId: string;
+        entry: string;
+    };
+    setDefaultApp: (feature: string, application: IApplicationController, entry: string) => void;
+}>;

package/dist/runtime/stores/storeDesktopDefaultApps.js

@@ -0,0 +1,21 @@
+import { defineStore } from "pinia";
+import { useDesktopStore } from "./storeDesktop.js";
+export const useDesktopDefaultAppsStore = defineStore(
+  "desktop/default-apps",
+  () => {
+    const desktopStore = useDesktopStore();
+    function getDefaultApp(feature) {
+      return desktopStore.state.defaultApps[feature];
+    }
+    function setDefaultApp(feature, application, entry) {
+      desktopStore.state.defaultApps[feature] = {
+        applicationId: application.id,
+        entry
+      };
+    }
+    return {
+      getDefaultApp,
+      setDefaultApp
+    };
+  }
+);

package/dist/runtime/stores/storeDesktopTray.d.ts

@@ -0,0 +1,6 @@
+import type { DesktopTrayItem } from '../../types/index.js';
+export declare const useDesktopTrayStore: import("pinia").SetupStoreDefinition<"desktop/tray", {
+    items: import("vue").Ref<any, any>;
+    registerIcon: (item: DesktopTrayItem) => void;
+    unregisterIcon: (id: string) => void;
+}>;

package/dist/runtime/stores/storeDesktopTray.js

@@ -0,0 +1,21 @@
+import { ref } from "vue";
+import { defineStore } from "pinia";
+export const useDesktopTrayStore = defineStore("desktop/tray", () => {
+  const items = ref([]);
+  function registerIcon(item) {
+    const existingIdx = items.value.findIndex((i) => i.id === item.id);
+    if (existingIdx >= 0) {
+      items.value[existingIdx] = item;
+    } else {
+      items.value.push(item);
+    }
+  }
+  function unregisterIcon(id) {
+    items.value = items.value.filter((i) => i.id !== id);
+  }
+  return {
+    items,
+    registerIcon,
+    unregisterIcon
+  };
+});

package/dist/runtime/stores/storeDesktopVolume.d.ts

@@ -0,0 +1,4 @@
+export declare const useDesktopVolumeStore: import("pinia").SetupStoreDefinition<"desktop/volume", {
+    master: import("vue").Ref<number, number>;
+    setMasterVolume: (value: number) => void;
+}>;

package/dist/runtime/stores/storeDesktopVolume.js

@@ -0,0 +1,12 @@
+import { ref } from "vue";
+import { defineStore } from "pinia";
+export const useDesktopVolumeStore = defineStore("desktop/volume", () => {
+  const master = ref(100);
+  function setMasterVolume(value) {
+    master.value = Math.max(0, Math.min(100, value));
+  }
+  return {
+    master,
+    setMasterVolume
+  };
+});

package/dist/runtime/stores/storeDesktopWorkspace.d.ts

@@ -0,0 +1,26 @@
+import type { DesktopWorkareaRect } from '../../types/index.js';
+export declare const EMPTY_DESKTOP_WORKAREA: DesktopWorkareaRect;
+export declare const useDesktopWorkspaceStore: import("pinia").SetupStoreDefinition<"desktop/workspace", {
+    list: import("vue").Ref<string[], string[]>;
+    active: import("vue").Ref<string, string>;
+    overview: import("vue").Ref<boolean, boolean>;
+    workarea: import("vue").Ref<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, DesktopWorkareaRect | {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    workspaceActiveIndex: import("vue").ComputedRef<number>;
+    setWorkspace: (workspaceId: string) => boolean;
+    setOverview: (value: boolean) => void;
+    toggleOverview: () => void;
+    setWorkarea: (rect: DesktopWorkareaRect) => void;
+    addWorkspace: (id?: string) => string;
+    removeWorkspace: (workspaceId: string) => boolean;
+    resolveWorkspaceFallback: (removedId: string) => string | null;
+}>;