akanjs 3.0.0-beta.20 → 3.0.0-beta.21

package/vendor/@akanjs/native/plugins/window/src/desktop.ts

@@ -0,0 +1,170 @@
+
+
+import { statSync } from "node:fs";
+import { basename } from "node:path";
+import { AkanNativeError, mimeFor } from "../../../packages/core/src/index.ts";
+import { createPageVeto, type DesktopContext, defineDesktopPlugin } from "../../../packages/desktop/src/plugin.ts";
+import type { DragDropEvent, WindowApi, WindowEvents, WindowInfo, WindowState } from "./index.ts";
+
+const closeVeto = createPageVeto();
+
+function finite(value: unknown, name: string): number {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    throw new AkanNativeError("INVALID_ARGS", `${name} must be a number`);
+  return value;
+}
+
+function bool(value: unknown, name: string): boolean {
+  if (typeof value !== "boolean") throw new AkanNativeError("INVALID_ARGS", `${name} must be a boolean`);
+  return value;
+}
+
+/** `{ window }` when the call names a target window, else {} (the calling window). */
+function target(args: unknown): { window?: number } {
+  const window = (args as { window?: unknown } | undefined)?.window;
+  if (window === undefined) return {};
+  if (typeof window !== "number" || !Number.isInteger(window) || window < 1)
+    throw new AkanNativeError("INVALID_ARGS", "window must be a window id");
+  return { window };
+}
+
+/** Regular files among the dropped paths, served at /__akan_native/file/<id>; folders and unreadable paths are left out. */
+export function droppedFiles(
+  ctx: Pick<DesktopContext, "registerFile">,
+  paths: string[],
+): NonNullable<DragDropEvent["files"]> {
+  const files: NonNullable<DragDropEvent["files"]> = [];
+  for (const path of paths) {
+    try {
+      if (!statSync(path).isFile()) continue;
+    } catch {
+      continue;
+    }
+    const name = basename(path);
+    files.push({ ...ctx.registerFile(path, mimeFor(name)), path, name });
+  }
+  return files;
+}
+
+/** The shell says "no window 7" for a window that is gone. */
+function shell(ctx: DesktopContext, op: string, args: unknown, extra: Record<string, unknown> = {}): Promise<unknown> {
+  return ctx.shell(`window.${op}`, { ...extra, ...target(args) }).catch((error) => {
+    const message = String((error as Error)?.message ?? error);
+    throw /^no window/.test(message) ? new AkanNativeError("NOT_FOUND", message) : error;
+  });
+}
+
+const op = (name: string) => (args: unknown, ctx: DesktopContext) => shell(ctx, name, args) as Promise<WindowState>;
+
+function createOptions(args: unknown): Record<string, unknown> {
+  const a = (args ?? {}) as Record<string, unknown>;
+  const out: Record<string, unknown> = {};
+  if (a.path !== undefined) {
+    if (typeof a.path !== "string" || !a.path.startsWith("/") || a.path.startsWith("//")) {
+      throw new AkanNativeError("INVALID_ARGS", "path must be an app path like /settings");
+    }
+    out.path = a.path;
+  }
+  if (a.title !== undefined) {
+    if (typeof a.title !== "string") throw new AkanNativeError("INVALID_ARGS", "title must be a string");
+    out.title = a.title;
+  }
+  for (const [x, y] of [
+    ["width", "height"],
+    ["x", "y"],
+  ] as const) {
+    if (a[x] === undefined && a[y] === undefined) continue;
+    out[x] = finite(a[x], x);
+    out[y] = finite(a[y], y);
+  }
+  if (out.width !== undefined && ((out.width as number) < 1 || (out.height as number) < 1)) {
+    throw new AkanNativeError("INVALID_ARGS", "width and height must be positive");
+  }
+  return out;
+}
+
+export default defineDesktopPlugin<WindowApi, WindowEvents>({
+  id: "window",
+  setup(ctx) {
+    ctx.onCloseRequested(({ window }) => closeVeto.ask({}, { window }));
+  },
+  methods: {
+    getState: op("getState"),
+    setTitle: (args, ctx) => {
+      if (typeof args?.title !== "string") throw new AkanNativeError("INVALID_ARGS", "title must be a string");
+      return shell(ctx, "setTitle", args, { title: args.title }) as Promise<WindowState>;
+    },
+    setSize: (args, ctx) => {
+      const width = finite(args?.width, "width");
+      const height = finite(args?.height, "height");
+      if (width < 1 || height < 1) throw new AkanNativeError("INVALID_ARGS", "width and height must be positive");
+      return shell(ctx, "setSize", args, { width, height }) as Promise<WindowState>;
+    },
+    setPosition: (args, ctx) =>
+      shell(ctx, "setPosition", args, { x: finite(args?.x, "x"), y: finite(args?.y, "y") }) as Promise<WindowState>,
+    center: op("center"),
+    minimize: op("minimize"),
+    maximize: op("maximize"),
+    unmaximize: op("unmaximize"),
+    restore: op("restore"),
+    setFullscreen: (args, ctx) =>
+      shell(ctx, "setFullscreen", args, { value: bool(args?.value, "value") }) as Promise<WindowState>,
+    setAlwaysOnTop: (args, ctx) =>
+      shell(ctx, "setAlwaysOnTop", args, { value: bool(args?.value, "value") }) as Promise<WindowState>,
+    show: op("show"),
+    hide: op("hide"),
+    focus: op("focus"),
+    startDragging: async (args, ctx) => {
+      await shell(ctx, "startDragging", args);
+    },
+    toggleMaximize: async (args, ctx) => {
+      const state = (await shell(ctx, "getState", args)) as WindowState;
+      return shell(ctx, state.maximized ? "unmaximize" : "maximize", args) as Promise<WindowState>;
+    },
+    close: async (args, ctx) => {
+      const named = target(args).window;
+      if (named !== undefined) await shell(ctx, "getState", args); 
+      const window = named ?? ctx.window ?? 1;
+      
+      setTimeout(() => ctx.closeWindow(window), 50);
+    },
+    create: (args, ctx) => ctx.shell("window.create", createOptions(args)) as Promise<WindowInfo>,
+    list: (_args, ctx) => ctx.shell("window.list") as Promise<WindowInfo[]>,
+    answerCloseRequested: (args, ctx) => closeVeto.answer(args, ctx.window),
+  },
+  events: {
+    
+    resize: (emit, ctx) =>
+      ctx.onNativeEvent("window", (e) => {
+        if (e.event === "resized")
+          emit({ width: e.width as number, height: e.height as number }, { window: (e.window as number) ?? 1 });
+      }),
+    move: (emit, ctx) =>
+      ctx.onNativeEvent("window", (e) => {
+        if (e.event === "moved") emit({ x: e.x as number, y: e.y as number }, { window: (e.window as number) ?? 1 });
+      }),
+    focus: (emit, ctx) =>
+      ctx.onNativeEvent("window", (e) => {
+        if (e.event === "focused") emit({ focused: e.value === true }, { window: (e.window as number) ?? 1 });
+      }),
+    closeRequested: (emit, ctx) => closeVeto.source(emit, ctx),
+    
+    created: (emit, ctx) =>
+      ctx.onNativeEvent("window", (e) => {
+        if (e.event === "created") emit({ id: e.window as number });
+      }),
+    destroyed: (emit, ctx) =>
+      ctx.onNativeEvent("window", (e) => {
+        if (e.event === "destroyed") emit({ id: e.window as number });
+      }),
+    
+    dragDrop: (emit, ctx) =>
+      ctx.onNativeEvent("dragDrop", (e) => {
+        const data: DragDropEvent = { type: e.event as DragDropEvent["type"] };
+        if (Array.isArray(e.paths)) data.paths = e.paths as string[];
+        if (typeof e.x === "number" && typeof e.y === "number") data.position = { x: e.x, y: e.y };
+        if (data.type === "drop") data.files = droppedFiles(ctx, data.paths ?? []);
+        emit(data, { window: (e.window as number) ?? 1 });
+      }),
+  },
+});

package/vendor/@akanjs/native/plugins/window/src/index.ts

@@ -0,0 +1,342 @@
+
+
+import * as React from "react";
+import {
+  createLiveValue,
+  definePlugin,
+  type FileRef,
+  platform,
+  type VetoHandler,
+  vetoable,
+  windowId,
+} from "../../../packages/core/src/index.ts";
+import { useLiveValue } from "../../../packages/react/src/index.ts";
+import { web } from "./web.ts";
+
+/** The app window (desktop). Sizes and positions are logical pixels (CSS px). */
+export interface WindowState {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  maximized: boolean;
+  minimized: boolean;
+  fullscreen: boolean;
+  focused: boolean;
+  visible: boolean;
+  title: string;
+}
+
+/** A window and its id (SH-6: 1 is the window the app opened; others come from createWindow). */
+export interface WindowInfo extends WindowState {
+  id: number;
+}
+
+/** Where a new window opens. Sizes and positions are logical pixels; x and y are the frame's top-left corner. */
+export interface CreateWindowOptions {
+  /** App path the window loads, e.g. "/settings" (the SPA router sees it). Default "/". */
+  path?: string;
+  /** Default: the app name. */
+  title?: string;
+  width?: number;
+  height?: number;
+  /** Default: offset from the focused window, like new documents on macOS. */
+  x?: number;
+  y?: number;
+}
+
+/** `window`: which window an op acts on. Default: the window of the page that calls. */
+type On = { window?: number };
+
+export interface WindowApi {
+  getState(args?: On): Promise<WindowState>;
+  setTitle(args: { title: string } & On): Promise<WindowState>;
+  setSize(args: { width: number; height: number } & On): Promise<WindowState>;
+  setPosition(args: { x: number; y: number } & On): Promise<WindowState>;
+  center(args?: On): Promise<WindowState>;
+  minimize(args?: On): Promise<WindowState>;
+  maximize(args?: On): Promise<WindowState>;
+  unmaximize(args?: On): Promise<WindowState>;
+  /** Un-minimize, un-maximize and focus. */
+  restore(args?: On): Promise<WindowState>;
+  setFullscreen(args: { value: boolean } & On): Promise<WindowState>;
+  setAlwaysOnTop(args: { value: boolean } & On): Promise<WindowState>;
+  show(args?: On): Promise<WindowState>;
+  hide(args?: On): Promise<WindowState>;
+  focus(args?: On): Promise<WindowState>;
+  /**
+   * Closes the window without asking onCloseRequested handlers. While another window exists it
+   * is destroyed; the last window makes the app quit (asking app.onBeforeQuit handlers), or only
+   * hides if desktop.quitOnLastWindowClosed is false.
+   */
+  close(args?: On): Promise<void>;
+  /** Moves the window with the mouse; call it from a mousedown on a custom title bar. */
+  startDragging(args?: On): Promise<void>;
+  toggleMaximize(args?: On): Promise<WindowState>;
+  /** Opens another window (desktop). Use createWindow(). */
+  create(args?: CreateWindowOptions): Promise<WindowInfo>;
+  /** Every window, hidden ones included, by id. Use getAllWindows(). */
+  list(): Promise<WindowInfo[]>;
+  /** Internal: the page's answer to a closeRequested event. Use onCloseRequested(). */
+  answerCloseRequested(args: { id: number; allow?: boolean }): Promise<void>;
+}
+
+export interface WindowEvents {
+  /** This window's inner size changed. */
+  resize: { width: number; height: number };
+  /** This window moved. */
+  move: { x: number; y: number };
+  /** This window gained or lost focus. */
+  focus: { focused: boolean };
+  /** Internal: the close button or Cmd+W on this window. Use onCloseRequested(). */
+  closeRequested: { id: number };
+  /** A window was opened (any window). */
+  created: { id: number };
+  /** A window was destroyed (any window). */
+  destroyed: { id: number };
+  /** Files dragged over this window from Finder or another app (desktop, plugins.md D9). Use onDragDrop(). */
+  dragDrop: DragDropEvent;
+}
+
+/**
+ * A file drag over the window (desktop). Only drags that carry files are reported. The page's own
+ * HTML5 drop events keep working next to it (dataTransfer.files, without paths).
+ */
+export interface DragDropEvent {
+  type: "enter" | "over" | "drop" | "leave";
+  /** Absolute paths of the dragged files and folders (enter and drop). */
+  paths?: string[];
+  /** Pointer position in CSS px from the page's top-left corner (not on leave). */
+  position?: { x: number; y: number };
+  /** On drop: every regular file, served by the host for this session so the page can fetch() it. */
+  files?: (FileRef & { path: string; name: string })[];
+}
+
+/** The window plugin. Its ops act on this page's window unless `window` says otherwise. */
+export const appWindow = definePlugin<WindowApi, WindowEvents>("window", {
+  methods: [
+    "getState",
+    "setTitle",
+    "setSize",
+    "setPosition",
+    "center",
+    "minimize",
+    "maximize",
+    "unmaximize",
+    "restore",
+    "setFullscreen",
+    "setAlwaysOnTop",
+    "show",
+    "hide",
+    "focus",
+    "close",
+    "startDragging",
+    "toggleMaximize",
+    "create",
+    "list",
+    "answerCloseRequested",
+  ],
+  events: ["resize", "move", "focus", "closeRequested", "created", "destroyed", "dragDrop"],
+  web,
+});
+
+/** One window, by id. Its methods act on that window from any page. */
+export interface WindowHandle {
+  readonly id: number;
+  /** True for the window this page runs in. */
+  readonly isCurrent: boolean;
+  getState(): Promise<WindowState>;
+  setTitle(title: string): Promise<WindowState>;
+  setSize(width: number, height: number): Promise<WindowState>;
+  setPosition(x: number, y: number): Promise<WindowState>;
+  center(): Promise<WindowState>;
+  minimize(): Promise<WindowState>;
+  maximize(): Promise<WindowState>;
+  unmaximize(): Promise<WindowState>;
+  restore(): Promise<WindowState>;
+  toggleMaximize(): Promise<WindowState>;
+  setFullscreen(value: boolean): Promise<WindowState>;
+  setAlwaysOnTop(value: boolean): Promise<WindowState>;
+  show(): Promise<WindowState>;
+  hide(): Promise<WindowState>;
+  focus(): Promise<WindowState>;
+  /** Closes it without asking its onCloseRequested handlers (see appWindow.close). */
+  close(): Promise<void>;
+  /** Calls `fn` once the window is destroyed. Returns an unregister function. */
+  onDestroyed(fn: () => void): () => void;
+}
+
+/** This page's window id: 1 for the window the app opened. 1 where there is only one window. */
+export const currentWindowId: number = windowId ?? 1;
+
+export function windowHandle(id: number): WindowHandle {
+  const on = { window: id };
+  return {
+    id,
+    isCurrent: id === currentWindowId,
+    getState: () => appWindow.getState(on),
+    setTitle: (title) => appWindow.setTitle({ title, ...on }),
+    setSize: (width, height) => appWindow.setSize({ width, height, ...on }),
+    setPosition: (x, y) => appWindow.setPosition({ x, y, ...on }),
+    center: () => appWindow.center(on),
+    minimize: () => appWindow.minimize(on),
+    maximize: () => appWindow.maximize(on),
+    unmaximize: () => appWindow.unmaximize(on),
+    restore: () => appWindow.restore(on),
+    toggleMaximize: () => appWindow.toggleMaximize(on),
+    setFullscreen: (value) => appWindow.setFullscreen({ value, ...on }),
+    setAlwaysOnTop: (value) => appWindow.setAlwaysOnTop({ value, ...on }),
+    show: () => appWindow.show(on),
+    hide: () => appWindow.hide(on),
+    focus: () => appWindow.focus(on),
+    close: () => appWindow.close(on),
+    onDestroyed(fn) {
+      const stop = appWindow.listen("destroyed", ({ id: gone }) => {
+        if (gone !== id) return;
+        stop();
+        fn();
+      });
+      return stop;
+    },
+  };
+}
+
+/** The window this page runs in. */
+export function getCurrentWindow(): WindowHandle {
+  return windowHandle(currentWindowId);
+}
+
+/**
+ * Opens another window that loads `path` of this app (desktop). It stays hidden until its page
+ * has loaded, like the first window. UNSUPPORTED on web, iOS and Android. Pages of different
+ * windows share storage (localStorage, IndexedDB) and can talk through BroadcastChannel.
+ */
+export async function createWindow(options: CreateWindowOptions = {}): Promise<WindowHandle> {
+  return windowHandle((await appWindow.create(options)).id);
+}
+
+/** Every window of the app, hidden ones included, by id. Only the current one where there is one window. */
+export async function getAllWindows(): Promise<WindowHandle[]> {
+  if (!appWindow.isSupported("list")) return [getCurrentWindow()];
+  return (await appWindow.list()).map((w) => windowHandle(w.id));
+}
+
+const DRAG_ATTR = "data-akan-native-drag-region";
+const CLICKABLE = new Set(["A", "BUTTON", "INPUT", "SELECT", "TEXTAREA", "LABEL", "SUMMARY"]);
+const INTERACTIVE_ROLES = new Set(["button", "link", "menuitem", "tab", "checkbox", "radio", "switch", "option"]);
+
+function isClickable(el: HTMLElement): boolean {
+  return (
+    CLICKABLE.has(el.tagName) ||
+    (el.hasAttribute("contenteditable") && el.getAttribute("contenteditable") !== "false") ||
+    (el.hasAttribute("tabindex") && el.getAttribute("tabindex") !== "-1") ||
+    INTERACTIVE_ROLES.has(el.getAttribute("role") ?? "")
+  );
+}
+
+export function isDragRegion(path: EventTarget[]): boolean {
+  for (const node of path) {
+    if (!(node instanceof HTMLElement)) continue;
+    const attr = node.getAttribute(DRAG_ATTR);
+    if (isClickable(node) && attr === null) return false;
+    if (attr === null) continue;
+    if (attr === "false") return false;
+    if (attr === "deep") return true;
+    if (attr === "" || attr === "true") return node === path[0];
+  }
+  return false;
+}
+
+function installDragRegions(): void {
+  if (typeof document === "undefined" || appWindow.implementation("startDragging") !== "native") return;
+  const mac = platform === "macos";
+  let downX = 0;
+  let downY = 0;
+  document.addEventListener("mousedown", (e) => {
+    if (e.button !== 0 || (e.detail !== 1 && e.detail !== 2) || !isDragRegion(e.composedPath())) return;
+    if (mac && e.detail === 2) {
+      downX = e.clientX;
+      downY = e.clientY;
+      return;
+    }
+    e.preventDefault(); 
+    e.stopImmediatePropagation();
+    void (e.detail === 2 ? appWindow.toggleMaximize() : appWindow.startDragging()).catch(() => {});
+  });
+  if (mac) {
+    document.addEventListener("mouseup", (e) => {
+      if (
+        e.button === 0 &&
+        e.detail === 2 &&
+        e.clientX === downX &&
+        e.clientY === downY &&
+        isDragRegion(e.composedPath())
+      ) {
+        void appWindow.toggleMaximize().catch(() => {});
+      }
+    });
+  }
+}
+
+installDragRegions();
+
+const state = createLiveValue<WindowState | null>(null, (set) => {
+  if (!appWindow.isSupported("getState")) return;
+  let live = true;
+  let last: WindowState | null = null;
+  const refresh = () =>
+    appWindow
+      .getState()
+      .then((s) => {
+        last = s;
+        if (live) set(s);
+      })
+      .catch(() => {});
+  const stops = [
+    appWindow.listen("resize", ({ width, height }) => {
+      if (!last) return;
+      last = { ...last, width, height };
+      set(last);
+    }),
+    appWindow.listen("move", ({ x, y }) => {
+      if (!last) return;
+      last = { ...last, x, y };
+      set(last);
+    }),
+    
+    appWindow.listen("focus", () => void refresh()),
+  ];
+  void refresh();
+  return () => {
+    live = false;
+    for (const stop of stops) stop();
+  };
+});
+
+/** The window state, kept up to date from resize/move/focus events. null until known or where unsupported. */
+export function useWindowState(): WindowState | null {
+  return useLiveValue(state);
+}
+
+/**
+ * Runs `handler` when the user asks to close this page's window (close button, Cmd+W). Call
+ * `event.preventDefault()` to keep it open, e.g. after asking to save. Without handlers, or if
+ * none prevents it, the window closes as usual. Desktop only: elsewhere it never fires
+ * (`appWindow.eventImplementation("closeRequested")` tells). Returns an unregister function.
+ */
+export const onCloseRequested: (handler: VetoHandler<{}>) => () => void = vetoable(
+  (listener) => appWindow.listen("closeRequested", listener),
+  (args) => appWindow.answerCloseRequested(args),
+);
+
+/** onCloseRequested while mounted; always calls the latest handler. */
+export function useCloseRequested(handler: VetoHandler<{}>): void {
+  const latest = React.useRef(handler);
+  latest.current = handler;
+  React.useEffect(() => onCloseRequested((event) => latest.current(event)), []);
+}
+
+/** Files dragged over this window (desktop). Returns an unsubscribe function; never fires on web or mobile. */
+export function onDragDrop(handler: (event: DragDropEvent) => void): () => void {
+  return appWindow.listen("dragDrop", handler);
+}

package/vendor/@akanjs/native/plugins/window/src/web.ts

@@ -0,0 +1,43 @@
+import { defineWebPlugin } from "../../../packages/core/src/index.ts";
+import type { WindowApi, WindowEvents, WindowState } from "./index.ts";
+
+function read(): WindowState {
+  return {
+    x: window.screenX,
+    y: window.screenY,
+    width: window.innerWidth,
+    height: window.innerHeight,
+    maximized: false,
+    minimized: document.visibilityState === "hidden",
+    fullscreen: document.fullscreenElement != null,
+    focused: document.hasFocus(),
+    visible: document.visibilityState === "visible",
+    title: document.title,
+  };
+}
+
+export const web = defineWebPlugin<WindowApi, WindowEvents>({
+  methods: {
+    getState: async () => read(),
+    async setTitle({ title }) {
+      document.title = String(title);
+      return read();
+    },
+  },
+  events: {
+    resize(emit) {
+      const on = () => emit({ width: window.innerWidth, height: window.innerHeight });
+      window.addEventListener("resize", on);
+      return () => window.removeEventListener("resize", on);
+    },
+    focus(emit) {
+      const on = () => emit({ focused: document.hasFocus() });
+      window.addEventListener("focus", on);
+      window.addEventListener("blur", on);
+      return () => {
+        window.removeEventListener("focus", on);
+        window.removeEventListener("blur", on);
+      };
+    },
+  },
+});

package/vendor/@akanjs/native/plugins/window-state/native-plugin.json

@@ -0,0 +1,10 @@
+{
+  "id": "window-state",
+  "apiVersion": 1,
+  "methods": ["getSaved", "save", "clear"],
+  "events": [],
+  "web": null,
+  "desktop": "./src/desktop.ts",
+  "ios": null,
+  "android": null
+}

package/vendor/@akanjs/native/plugins/window-state/src/desktop.ts

@@ -0,0 +1,73 @@
+
+
+import { readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { type DesktopContext, defineDesktopPlugin, type NativeEvent } from "../../../packages/desktop/src/plugin.ts";
+import type { SavedWindowState, WindowStateApi } from "./index.ts";
+import { createTracker, parseSaved, serialize, type Tracker, type WindowSnapshot } from "./state.ts";
+
+export const STATE_FILE = "window-state.json";
+
+function readText(path: string): string | null {
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+/** Write to a temporary file and rename: a crash mid-write never leaves half a file. */
+function writeAtomic(path: string, text: string): void {
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, text);
+  renameSync(tmp, path);
+}
+
+export function createDesktopWindowState(options: { delay?: number } = {}) {
+  let tracker: Tracker | null = null;
+  let file = "";
+
+  const start = (ctx: DesktopContext) => {
+    file = join(ctx.appDataDir, STATE_FILE);
+    const initial = parseSaved(readText(file));
+    if (initial) ctx.launch.setWindow(initial);
+    const t = createTracker({
+      initial,
+      delay: options.delay,
+      
+      read: () => ctx.shell("window.getState", { window: 1 }) as Promise<WindowSnapshot>,
+      write: (state) => writeAtomic(file, serialize(state)),
+    });
+    tracker = t;
+    const main = (e: NativeEvent) => e.window === undefined || e.window === 1;
+    ctx.onNativeEvent("window", (e) => {
+      if ((e.event === "moved" || e.event === "resized") && main(e)) t.changed();
+    });
+    
+    ctx.onNativeEvent("pageLoad", (e) => {
+      if (e.event === "finished" && main(e)) t.changed();
+    });
+    ctx.onQuit(() => t.flush().then(() => {}));
+  };
+
+  const need = (): Tracker => {
+    if (!tracker) throw new Error("window-state is not set up");
+    return tracker;
+  };
+  const result = (state: SavedWindowState | null) => ({ state: state && { ...state } });
+
+  return defineDesktopPlugin<WindowStateApi>({
+    id: "window-state",
+    setup: start,
+    methods: {
+      getSaved: () => result(need().saved),
+      save: async () => result(await need().flush()),
+      clear: () => {
+        need().clear();
+        rmSync(file, { force: true });
+      },
+    },
+  });
+}
+
+export default createDesktopWindowState();

package/vendor/@akanjs/native/plugins/window-state/src/index.ts

@@ -0,0 +1,35 @@
+import { definePlugin } from "../../../packages/core/src/index.ts";
+
+/**
+ * Remembers the desktop window's position, size and maximized state across launches.
+ * Adding the plugin to akan-native.config.ts is all it takes: bounds are saved while the user moves
+ * or resizes the window and restored before the window is first shown (no visible jump).
+ *
+ * - Bounds are logical points of the normal (not maximized, not minimized, not full-screen)
+ *   window, like Tauri's window-state; `maximized` is kept separately so un-maximizing after a
+ *   restart returns to the last normal bounds.
+ * - A saved position whose title bar would be off every connected display is dropped, and the
+ *   window opens at the default place (a display was unplugged).
+ * - Full screen is not restored: on macOS it would open a new Space at launch.
+ * - Web, iOS and Android: UNSUPPORTED (the OS owns the window there).
+ */
+export interface SavedWindowState {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  maximized: boolean;
+}
+
+export interface WindowStateApi {
+  /** What the next launch will restore, or null when nothing is saved yet. */
+  getSaved(): Promise<{ state: SavedWindowState | null }>;
+  /** Saves the current bounds now instead of after the next move or resize settles. */
+  save(): Promise<{ state: SavedWindowState | null }>;
+  /** Forgets the saved state: the next launch uses the configured size again. */
+  clear(): Promise<void>;
+}
+
+export const windowState = definePlugin<WindowStateApi>("window-state", {
+  methods: ["getSaved", "save", "clear"],
+});