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

package/dist/runtime/internal/controllers/WindowController.d.ts

@@ -0,0 +1,83 @@
+import { type WindowConfig, type WindowLayout, type WindowOverride, type WindowSizeValue, type WindowState, type WindowStoredState } from '@owdproject/core';
+import type { IDesktopWindowActions, IDesktopWindowController } from '../../../types/index.js';
+export declare class WindowController implements IDesktopWindowController {
+    readonly application: any;
+    readonly instanced: boolean;
+    readonly model: string;
+    private readonly _stateValue;
+    get stateValue(): string;
+    config: WindowConfig;
+    override: WindowOverride;
+    private storedState;
+    private windowActor;
+    private isDisposed;
+    readonly actions: IDesktopWindowActions;
+    constructor(application: any, model: string, windowConfig: WindowConfig, windowStoredState: WindowStoredState, options?: {
+        onFocus?: (win: WindowController) => void;
+        onLayoutChange?: (win: WindowController, layout: WindowLayout) => void;
+        getWorkarea?: () => {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        incrementPositionZ?: () => number;
+        getWindows?: () => WindowController[];
+    });
+    private setConfig;
+    get state(): WindowState;
+    private restoreState;
+    get meta(): any;
+    setPosition(data: {
+        x: number;
+        y: number;
+    }): void;
+    setActive(value: boolean): void;
+    setFocus(value: boolean): void;
+    focus(): void;
+    get title(): string;
+    get windowTitle(): string;
+    get icon(): any;
+    get position(): import("@owdproject/core").WindowPosition | undefined;
+    get size(): {
+        width: WindowSizeValue;
+        height: WindowSizeValue;
+        minWidth: WindowSizeValue;
+        maxWidth: WindowSizeValue;
+        minHeight: WindowSizeValue;
+        maxHeight: WindowSizeValue;
+    };
+    setSize(data: {
+        width: number;
+        height: number;
+    }): void;
+    get isMinimizable(): boolean;
+    minimize(): boolean;
+    unminimize(): boolean;
+    toggleMinimize(): void;
+    get isMaximizable(): boolean;
+    get isMaximized(): boolean;
+    private parseSizeValue;
+    saveBoundsBeforeLayout(): void;
+    setLayout(layout: WindowLayout): boolean;
+    clearLayout(): boolean;
+    toggleMaximize(): boolean;
+    maximize(): boolean;
+    unmaximize(): boolean;
+    get isDestroyable(): boolean;
+    dispose(): void;
+    destroy(): boolean;
+    get isDraggable(): boolean;
+    get isResizable(): boolean;
+    setWorkspace(workspaceId: string): void;
+    startDrag(): void;
+    stopDrag(): void;
+    startResize(): void;
+    stopResize(): void;
+    setTitleOverride(value: undefined | string): void;
+    resetTitleOverride(): void;
+    setWindowTitleOverride(value: undefined | string): void;
+    resetWindowTitleOverride(): void;
+    menu: any[];
+    setMenu(menu: any[]): void;
+}

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,30 @@
+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 };
+      },
+      {
+        // Inert unless an optional persistence module registers the adapter.
+        // @ts-expect-error pinia-plugin-persistedstate-2 store option
+        persistedState: {
+          persist: true
+        }
+      }
+    );
+    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,43 @@
+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
+        };
+      },
+      {
+        // Inert unless an optional persistence module registers the adapter.
+        // @ts-expect-error pinia-plugin-persistedstate-2 store option
+        persistedState: {
+          persist: true
+        }
+      }
+    );
+    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,29 @@
+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
+    };
+  },
+  {
+    // Inert unless an optional persistence module (@owdproject/nuxt-module-pinia-persistence
+    // or @owdproject/nuxt-module-atproto-persistence) registers the adapter.
+    // @ts-expect-error pinia-plugin-persistedstate-2 store option
+    persistedState: {
+      persist: true,
+      // `defaultApps` is rebuilt from config on boot; persist only the z-index seed.
+      includePaths: ["state.positionZ"]
+    }
+  }
+);

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;
+}>;