@preset.nz/app-kit 0.1.0 → 0.1.2

package/README.md

@@ -51,11 +51,12 @@ tauri::Builder::default()
 
 - **`Command`**: id, menu label, optional toolbar label, Tauri accelerator, `MenuName` (App, File, Edit, View, Window, Help), `section` (items in a section sit together), item or toggle. Undo and Redo are built in; Settings is opt-in.
 - **File menu**: New, Open…, Open Recent ▸, Close, Save, Save As… and Revert to Saved… are built in, run against the app's `Document` behind the close guard. Revert is enabled only for an unsaved document with a file, and asks first, because reloading starts an empty history. Open Recent keeps ten documents, newest first, in `recent-documents.json` in the app's data directory; a file that has gone says so and leaves the list. `note_recent(app, path)` adds a document opened some other way (from the Finder, or by restore), and `recent_documents(app)[0]` is the last document. `.documents_folder(|app| …)` names where the Open and Save panels start for an Untitled document (`~/preset-nz/<App>/…`); the app supplies the lookup, so app-kit doesn't depend on app-folders.
+- **Relaunch**: `.plugin(preset_app_kit::window_state())` on the builder brings each window back at its size and position (`tauri-plugin-window-state`, not visibility). `on_run_event` reopens the last document at launch, the first entry of Open Recent, and opens a document the Finder hands over (double-click, `open some.x`, the Dock), which wins over the restored one. A last document that has gone, or won't load, becomes a note, not a dialog: register `app_kit_document_note` and show what `useDocumentNotes` hands you. For an app with documents, app-kit owns Finder opens, so don't add a second handler.
 - **Menu config**: `.menu_config(include_str!("../menu.toml"))` switches the built-in items on and off: `[file] new, open, open_recent, close, save, save_as, revert` and `[app] settings`. A missing key takes the default (on); an unknown key is an error, so add a test that calls `MenuConfig::parse` on your file. Labels, accelerators and positions stay the standard's. Design: guidance `projects/app-kit/design/menu-config.md`.
 - **Apps without documents**: `install_history::<H: History>` instead of `install::<H: Document>`, for a library such as Strata. The config must turn New, Open, Open Recent, Save, Save As and Revert off; with Close off too, Window gains Close Window on Cmd+W. No close guard, no window-title handling, and it doesn't register `tauri-plugin-dialog`, so the app keeps its own.
 - **`History`**: `undo_label`, `redo_label`, `undo_labels` (oldest first), `redo_labels` (next first), `undo`, `redo`. Implement it on the type you manage as Tauri state. The reads may lock, so call `refresh_history(app)` after a change and never while holding that lock.
 - **`edit_titles`**: the pure rule behind Edit > Undo: "Undo Set Opacity" when there is a step, plain and disabled when there is none, plain and enabled while a text field has focus.
-- **Events**: `command` (id, to the main window), `text-undo` (to the focused window), `app-kit://history` (a `HistoryState`).
+- **Events**: `command` (id, to the main window), `text-undo` (to the focused window), `app-kit://history` (a `HistoryState`), `app-kit://document` (a `DocumentState`), `app-kit://note` (a string).
 - Commands are plain Tauri commands, not a plugin, so no capability entries are needed.
 
 ## TypeScript
@@ -70,6 +71,7 @@ const { commands, run, shortcut } = useCommands(bindings) // bindings: Record<id
 - **`useCommands(bindings)`**: loads the table from Rust, binds `run`, icon and gating by id, follows the history, routes text-field undo and keeps the menu's enabled and checked state in step. `edit.undo` and `edit.redo` need only an icon. `bindCommands`, `useCommandTable`, `useMenuSync`, `toItems` are the parts.
 - **`CommandToolbar`**: ux-kit's `ToolbarItems` fed from the commands.
 - **`@preset.nz/app-kit/core`**: everything except `CommandToolbar` and `toItems`, with no ux-kit import, for apps that use only the menu half. ux-kit is an optional peer.
+- **`useDocument`, `useDocumentNotes(onNote)`**: the live `DocumentState`, and notes about the document (a last document that wouldn't reopen), each delivered once. Show a note as a snackbar.
 - **`useHistory`, `undo`, `redo`**: the live `HistoryState`, and the same undo the menu takes. The Inspector's History list reads `undoLabels` and `redoLabels`.
 - **`useTextUndo`, `useTextFocus`, `isTextField`, `blurField`**: Cmd+Z undoes typing while a text field has focus, the document otherwise.
 - **`createSelection<T>(none)`**: single-select store with `get`, `use`, `select`, `clear`. **`createMultiSelection<T>(key)`**: the opt-in multi-select. **`createStore`, `useStore`**: the small store under both. Wrap them in your own narrow setters; there is no `setSelection`, and selection is not an undo step.
@@ -94,4 +96,4 @@ In Vite, add `@preset.nz/app-kit` (with `react`, `react-dom`, `@tauri-apps/api`,
 
 ## Development
 
-`just check` runs `cargo fmt --check`, clippy, `cargo test`, `tsc` and eslint. MIT.
+`just check` runs `cargo fmt --check`, clippy, `cargo test`, `tsc` and Biome. MIT.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@preset.nz/app-kit",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "The behaviour of a preset.nz desktop app: command table, menu sync, Undo and Redo titles, text-field undo routing and a selection store, over the preset-app-kit Rust crate.",
   "license": "MIT",
   "repository": {
@@ -22,19 +22,15 @@
     "react": "^19"
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.4",
+    "@biomejs/biome": "^2.5.15",
     "@preset.nz/ux-kit": "^0.1.0",
     "@tauri-apps/api": "^2.11.1",
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
-    "eslint": "^9.39.4",
-    "eslint-plugin-react-hooks": "^7.1.1",
-    "eslint-plugin-react-refresh": "^0.5.3",
-    "globals": "^16.5.0",
+    "lefthook": "^2.1.17",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
-    "typescript": "~5.9.3",
-    "typescript-eslint": "^8.61.1"
+    "typescript": "~5.9.3"
   },
   "peerDependenciesMeta": {
     "@preset.nz/ux-kit": {

package/src-ts/CommandToolbar.tsx

@@ -1,10 +1,13 @@
-import type { ComponentProps } from "react"
 import { ToolbarItems } from "@preset.nz/ux-kit"
+import type { ComponentProps } from "react"
 
 import type { Command } from "./commands"
-import { toItems, type ToolbarLayout } from "./toolbar"
+import { type ToolbarLayout, toItems } from "./toolbar"
 
-type Props = Omit<ComponentProps<typeof ToolbarItems>, "groups" | "leading" | "trailing" | "onCommand"> & {
+type Props = Omit<
+  ComponentProps<typeof ToolbarItems>,
+  "groups" | "leading" | "trailing" | "onCommand"
+> & {
   commands: Command[]
   layout: ToolbarLayout
   /** From `useCommands`: runs the command the menu would. */

package/src-ts/commands.ts

@@ -1,7 +1,7 @@
-import { useCallback, useEffect, useMemo, useState, type ReactNode } from "react"
 import { invoke } from "@tauri-apps/api/core"
+import { type ReactNode, useCallback, useEffect, useMemo, useState } from "react"
 
-import { redo, undo, useHistory, type HistoryState } from "./history"
+import { type HistoryState, redo, undo, useHistory } from "./history"
 import { useTextUndo } from "./text"
 import { useMenuSync } from "./useMenuSync"
 
@@ -133,6 +133,9 @@ export function useCommands(bindings: Record<string, Binding>) {
     [commands],
   )
   /** A command's display shortcut, for anything that shows one (a panel header's tooltip). */
-  const shortcut = useCallback((id: string) => table?.find((s) => s.id === id)?.shortcut ?? undefined, [table])
+  const shortcut = useCallback(
+    (id: string) => table?.find((s) => s.id === id)?.shortcut ?? undefined,
+    [table],
+  )
   return { commands, run, shortcut, history }
 }

package/src-ts/core.ts

@@ -1,15 +1,15 @@
 // The menu half of app-kit: commands, history, text-field undo, selection and stores, with
 // no dependency on ux-kit. `index.ts` adds the toolbar bridge on top.
 export {
-  bindCommands,
-  useCommands,
-  useCommandTable,
   type Binding,
+  bindCommands,
   type Command,
   type CommandSpec,
+  useCommands,
+  useCommandTable,
 } from "./commands"
-export { useDocument, type DocumentState } from "./document"
-export { redo, undo, useHistory, type HistoryState } from "./history"
+export { type DocumentState, useDocument, useDocumentNotes } from "./document"
+export { type HistoryState, redo, undo, useHistory } from "./history"
 export { nativeContextMenu } from "./nativeContextMenu"
 export {
   createMultiSelection,
@@ -18,6 +18,6 @@ export {
   type MultiSelection,
   type Selection,
 } from "./selection"
-export { createStore, useStore, type Store } from "./store"
+export { createStore, type Store, useStore } from "./store"
 export { blurField, isTextField, useTextFocus, useTextUndo } from "./text"
 export { useMenuSync } from "./useMenuSync"

package/src-ts/document.ts

@@ -1,6 +1,6 @@
-import { useEffect, useState } from "react"
 import { invoke } from "@tauri-apps/api/core"
 import { listen } from "@tauri-apps/api/event"
+import { useEffect, useRef, useState } from "react"
 
 /** The document as Rust reports it (`DocumentState`): from `app_kit_document`, pushed as `app-kit://document`. */
 export interface DocumentState {
@@ -29,3 +29,32 @@ export function useDocument(): DocumentState | null {
   }, [])
   return state
 }
+
+/**
+ * Notes about the document for the app to show, such as a last document that wouldn't reopen
+ * at launch. Each arrives once: the ones held from before the webview listened, then any later
+ * `app-kit://note`. Show them as the app shows a passing message (a snackbar), never a dialog.
+ */
+export function useDocumentNotes(onNote: (message: string) => void): void {
+  const handler = useRef(onNote)
+  useEffect(() => {
+    handler.current = onNote
+  }, [onNote])
+  useEffect(() => {
+    let live = true
+    const un = listen<string>("app-kit://note", (e) => handler.current(e.payload))
+    // Ask only once listening, so nothing falls between the held notes and the event. And only
+    // while still mounted: taking them is once-only, so an unmounted effect (StrictMode mounts
+    // twice in dev) must leave them for the next.
+    un.then(() => (live ? invoke<string[]>("app_kit_document_note") : [])).then(
+      (held) => {
+        if (live) for (const m of held) handler.current(m)
+      },
+      () => {},
+    )
+    return () => {
+      live = false
+      un.then((f) => f())
+    }
+  }, [])
+}

package/src-ts/history.ts

@@ -1,6 +1,6 @@
-import { useEffect, useState } from "react"
 import { invoke } from "@tauri-apps/api/core"
 import { listen } from "@tauri-apps/api/event"
+import { useEffect, useState } from "react"
 
 import { blurField } from "./text"
 

package/src-ts/index.ts

@@ -1,5 +1,6 @@
 // Everything: the core plus the ux-kit toolbar bridge. Apps without ux-kit import
 // "@preset.nz/app-kit/core" instead.
-export * from "./core"
+
 export { CommandToolbar } from "./CommandToolbar"
-export { toItems, type ToolbarLayout } from "./toolbar"
+export * from "./core"
+export { type ToolbarLayout, toItems } from "./toolbar"

package/src-ts/store.ts

@@ -15,7 +15,7 @@ export function createStore<T>(initial: T): Store<T> {
     set(next) {
       if (Object.is(next, state)) return
       state = next
-      listeners.forEach((l) => l())
+      for (const l of listeners) l()
     },
     subscribe(l) {
       listeners.add(l)

package/src-ts/text.ts

@@ -1,13 +1,23 @@
-import { useEffect, useState } from "react"
 import { getCurrentWebviewWindow } from "@tauri-apps/api/webviewWindow"
+import { useEffect, useState } from "react"
 
-const TEXT_INPUT_TYPES = new Set(["", "text", "search", "url", "email", "tel", "password", "number"])
+const TEXT_INPUT_TYPES = new Set([
+  "",
+  "text",
+  "search",
+  "url",
+  "email",
+  "tel",
+  "password",
+  "number",
+])
 
 /** True for elements that have their own typing undo: text inputs, textareas, contenteditable. */
 export function isTextField(el: EventTarget | Element | null): boolean {
   if (!(el instanceof HTMLElement)) return false
   if (el instanceof HTMLTextAreaElement) return !el.readOnly && !el.disabled
-  if (el instanceof HTMLInputElement) return TEXT_INPUT_TYPES.has(el.type) && !el.readOnly && !el.disabled
+  if (el instanceof HTMLInputElement)
+    return TEXT_INPUT_TYPES.has(el.type) && !el.readOnly && !el.disabled
   return el.isContentEditable
 }
 

package/src-ts/useMenuSync.ts

@@ -1,6 +1,6 @@
-import { useEffect, useRef } from "react"
 import { invoke } from "@tauri-apps/api/core"
 import { getCurrentWebviewWindow } from "@tauri-apps/api/webviewWindow"
+import { useEffect, useRef } from "react"
 
 import type { Command } from "./commands"
 
@@ -31,12 +31,11 @@ export function useMenuSync(commands: Command[], textFocus: boolean) {
   }, [])
 
   const key = JSON.stringify(commands.map((c) => [c.id, c.enabled, c.pressed])) + textFocus
+  // biome-ignore lint/correctness/useExhaustiveDependencies: `key` stands for the commands' menu-relevant state (and textFocus); `latest` holds the commands themselves.
   useEffect(() => {
     const states = latest.current
       .filter((c) => !RUST_GATED_IDS.has(c.id))
       .map((c) => ({ id: c.id, enabled: c.enabled, checked: c.pressed }))
     invoke("app_kit_menu_state", { states, textFocus }).catch(() => {})
-    // `key` stands for the commands' menu-relevant state; `latest` holds the commands.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [key])
 }