deck-plugin-sdk 1.12.1 → 1.12.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deck-plugin-sdk",
-  "version": "1.12.1",
+  "version": "1.12.3",
   "description": "Build a plugin for Deck, outside the Deck repository.",
   "type": "module",
   "license": "MIT",

package/template/plugin.json

@@ -5,6 +5,6 @@
   "icon": "Sparkles",
   "color": "#a78bfa",
   "version": "0.1.0",
-  "minDeck": "1.12.1",
+  "minDeck": "1.12.3",
   "permissions": []
 }

package/types/components/MarkdownToolbar.d.ts

@@ -26,10 +26,20 @@ export interface TextSurface {
     focus(): void;
     /** Whether the keyboard is in this text, for the markdown keys (Ctrl+B, Ctrl+I). */
     hasFocus(): boolean;
+    /** Where the selection is on screen (window coordinates), or null when nothing is selected or
+     *  it is out of view: where a floating toolbar goes. A surface without it never floats. */
+    selectionBox?(): {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    } | null;
+    /** Calls `fn` whenever the selection or the scroll changes; returns the unsubscribe. */
+    watch?(fn: () => void): () => void;
 }
 /** A TextSurface over a CodeMirror EditorView. */
 export declare function cmSurface(view: EditorView): TextSurface;
-export declare function MarkdownToolbar({ surface, zoom, onZoom, floating, view }: {
+export declare function MarkdownToolbar({ surface, zoom, onZoom, floating }: {
     /** The editor to drive. Null disables every button — there is nothing to type into. */
     surface: TextSurface | null;
     /** Current text size in px. Omit to hide the zoom controls entirely. */
@@ -41,10 +51,11 @@ export declare function MarkdownToolbar({ surface, zoom, onZoom, floating, view
      *
      * Omit it and the editor's own "Floating markdown toolbar" setting decides, which is what
      * every caller should do — this exists only for a surface that has a reason to override it.
-     * Needs `view`, which is what turns a document offset into screen coordinates.
+     * Needs a surface that says where its selection is (selectionBox: both of Deck's do). The bar is
+     * placed in its own positioned parent, which should be the box the editor fills.
      */
     floating?: boolean;
-    /** The CodeMirror view, for positioning a floating bar. Ignored otherwise. */
+    /** No longer needed: the surface says where its selection is. Kept so plugins passing it still compile. */
     view?: EditorView | null;
 }): import("react").JSX.Element;
 export default MarkdownToolbar;

package/types/core/bridge.d.ts

@@ -260,7 +260,6 @@ export interface Settings {
     startMinimized: boolean;
     reduceMotion: boolean;
     /** The Servers list (hosts from ~/.ssh/config) under the workspace list. */
-    serversList: boolean;
     /** The mouse wheel over a tab bar switches tabs rather than scrolling the bar. */
     tabWheelSwitch: boolean;
     /** When the tabs do not fit, every one but the open tab shrinks to its icon. */
@@ -588,8 +587,9 @@ export interface ExecOut {
  * Run a command to completion and read its output. `runScriptNow` is fire-and-forget; this is
  * for when the output IS the point — asking a tool what it knows rather than telling it to do
  * something. A bare name goes through cmd.exe, so PATH and .bat shims (`flutter`, `npm`) work.
+ * `env` adds variables for this run only (a CLI's token), never seen by anything else.
  */
-export declare const exec: (command: string, args?: string[], cwd?: string) => Promise<ExecOut>;
+export declare const exec: (command: string, args?: string[], cwd?: string, env?: Record<string, string>) => Promise<ExecOut>;
 /** One header, one value. A list rather than a map: order matters, and repeats are legal. */
 export type HttpHeader = [string, string];
 export interface HttpSendRequest {
@@ -934,7 +934,7 @@ export interface ProcResult {
  * command and read the output" into driving a long-lived tool that takes commands — a daemon
  * speaking one JSON object per line, or a program reading single keypresses.
  */
-export declare const procStream: (id: string, program: string, args: string[], cwd?: string, stdin?: boolean) => Promise<ProcResult>;
+export declare const procStream: (id: string, program: string, args: string[], cwd?: string, stdin?: boolean, env?: Record<string, string>) => Promise<ProcResult>;
 /** What receives a `procStreamBytes` run's stdout, one chunk at a time. */
 export type ByteSink = (chunk: Uint8Array) => void;
 /**

package/types/core/editor/lsp.d.ts

@@ -182,14 +182,13 @@ export declare function setLspOpenFileHandler(fn: OpenFileHandler): void;
 export declare function stopIdleServers(now?: number): string[];
 /** Stop all sessions (e.g. on workspace close). */
 export declare function lspStopAll(): void;
-/** Restart one server (UI action from the status popover). */
 /**
  * Stop a language server. The next file opened for that root starts a fresh one, which is why
- * this is both the Restart action and the memory readout's stop button — there is no difference
- * between the two beyond what the caller says about it.
+ * this is the Restart action, the popover's × and the memory readout's stop button. `forget`
+ * (the last two) shows it as stopped rather than restarting, and lets an edit start it again.
  *
  * Deleting the frontend session alongside the process matters: leaving it would send didOpen to
  * a dead pipe on the next open, and the editor would sit at "ready" with no diagnostics.
  */
-export declare function lspRestart(id: string): Promise<void>;
+export declare function lspRestart(id: string, forget?: boolean): Promise<void>;
 export {};

package/types/core/workspaces/layout.d.ts

@@ -49,6 +49,9 @@ export interface LayoutTab {
      * the main window. Dropped the moment the tab is moved by hand: then it is one of yours.
      */
     transient?: true;
+    /** Pinned from its menu (tabops.ts): only its icon, before the unpinned tabs beside it, and left
+     *  open by Close others, Close to the right and Close all. */
+    pinned?: true;
 }
 export interface LayoutWorkspace {
     id: string;

package/types/core/workspaces/zones.d.ts

@@ -84,6 +84,12 @@ export declare function reorderTab(tabs: readonly LayoutTab[], srcId: string, ov
  *  (null: none, held over a tab outside any group or over a group's chip). Left out, the tabs
  *  either side decide (settleGroup). */
 group?: string | null): LayoutTab[];
+/**
+ * Each strip's pinned tabs (tabops.ts) before its unpinned ones, each side kept in its order: a drag
+ * can neither take a pinned tab among the others nor put another before the pinned ones. Takes a
+ * placed list (placeAll), whose zones a reorder of the list cannot change.
+ */
+export declare function pinnedFirst(tabs: LayoutTab[]): LayoutTab[];
 /**
  * A tab group's tabs sit together in their zone's row: a tab dropped between two of one group's
  * tabs joins it, and one moved away from every other tab of its own group leaves it. Next to one
@@ -170,9 +176,10 @@ export declare function showActiveTab(w: LayoutWorkspace): LayoutWorkspace;
 /**
  * Which tab becomes active when `closing` goes: the one beside it in the same zone (the next, or
  * the one before when it was last), as a browser does, so closing a tab neither throws you out of
- * the zone nor back to its first tab; otherwise the first zone left.
+ * the zone nor back to its first tab; otherwise the first zone left. A tab in a folded group is
+ * passed over for the nearest one that is not, so closing a tab does not open a group.
  */
-export declare function nextActiveAfterClose(tabs: readonly LayoutTab[], closing: string): string | undefined;
+export declare function nextActiveAfterClose(tabs: readonly LayoutTab[], closing: string, groups?: readonly TabGroup[]): string | undefined;
 /**
  * Tear a tab off into window `win`, or (`win` undefined) dock it back. A workspace always keeps
  * one docked tab: floating its last one leaves a fresh terminal behind, as the main window has

package/types/modules/editor/viewers/MarkdownLive.d.ts

@@ -1,10 +1,13 @@
 // GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
 import { EditorView } from "@codemirror/view";
-export declare function MarkdownLive({ value, path, onChange, onSave, onView, flush, fontSize, onWikiLink, resolveWikiLink, wikiLinkOptions, mermaid, resolveEmbed }: {
+export declare function MarkdownLive({ value, path, onChange, onSave, onView, flush, fontSize, onWikiLink, resolveWikiLink, wikiLinkOptions, mermaid, resolveEmbed, onOpenLink }: {
     value: string;
     path?: string;
     onChange: (v: string) => void;
     onSave?: () => void;
+    /** A click on a `[text](url)` link or a bare address, with its address as written. Omit it and a
+     *  web address opens in Deck's browser, another scheme (mailto:) with the system, a path not at all. */
+    onOpenLink?: (href: string) => void;
     /** Hands the live EditorView out, and null on unmount. For a formatting toolbar, which has to
      *  dispatch into this editor rather than rewrite the string around it. */
     onView?: (v: EditorView | null) => void;

package/types/modules/editor/viewers/live/blocks.d.ts

@@ -0,0 +1,36 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { type Extension } from "@codemirror/state";
+import { EditorView, WidgetType } from "@codemirror/view";
+/**
+ * A rendered mermaid diagram in place of its ```mermaid fence.
+ *
+ * A StateField rather than part of the ViewPlugin above, because CodeMirror refuses a
+ * plugin-supplied decoration that replaces a line break or sets `block: true` — and a fenced
+ * block is several lines. A StateField is the documented exception (see decorateTable, which
+ * hits the same wall from the other side).
+ *
+ * Rendering is asynchronous: mermaid parses and lays out, so the widget draws a placeholder of
+ * the same width and swaps the SVG in when it resolves, calling requestMeasure so CodeMirror's
+ * height map learns the real height rather than staying short by the diagram.
+ */
+export declare class MermaidWidget extends WidgetType {
+    readonly code: string;
+    constructor(code: string);
+    eq(o: MermaidWidget): boolean;
+    toDOM(view: EditorView): HTMLDivElement;
+    destroy(dom: HTMLElement): void;
+    ignoreEvent(): boolean;
+    get estimatedHeight(): number;
+}
+/** Text from inside a `> ` quote (or a callout) without the quote markers that start each line. */
+export declare const unquote: (s: string) => string;
+/** Load mermaid on first use and render one diagram to SVG. */
+export declare function renderMermaid(id: string, code: string): Promise<string>;
+/**
+ * The block-level widgets: a mermaid fence and a `$$maths$$` block.
+ *
+ * Both live here rather than in the live-preview ViewPlugin because CodeMirror refuses a
+ * plugin-supplied decoration that replaces a line break or sets `block: true`, and both span
+ * lines. `mermaid` gates only the diagrams — maths is drawn wherever this file is used.
+ */
+export declare function blockWidgetField(mermaid: boolean): Extension;

package/types/modules/editor/viewers/live/codehl.d.ts

@@ -0,0 +1,9 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { ViewPlugin, type DecorationSet, type EditorView, type ViewUpdate } from "@codemirror/view";
+/** The code-block colours and copy buttons, as a ViewPlugin beside the live preview's own. */
+export declare function codeBlocksExt(): ViewPlugin<{
+    decorations: DecorationSet;
+    readonly view: EditorView;
+    destroy(): void;
+    update(u: ViewUpdate): void;
+}, undefined>;

package/types/modules/editor/viewers/live/decorate.d.ts

@@ -0,0 +1,20 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { Decoration, type DecorationSet, type EditorView } from "@codemirror/view";
+import type { Extension, Range } from "@codemirror/state";
+import type { SyntaxNode } from "@lezer/common";
+export declare const replaceHide: Decoration;
+/**
+ * Decorate one GFM Table: hide its syntax and line the columns up.
+ *
+ * Column widths are applied as `min-width` in `ch` units on the cells, so nothing is written
+ * into the document — no padding spaces to undo, and any other editor sees exactly what was typed.
+ * That only measures correctly because `.cm-table-l` is monospace.
+ *
+ * ponytail: assumes leading and trailing pipes (`| a | b |`), which is what the toolbar
+ * generates and what Obsidian writes. A borderless `a | b` table still parses, but its first
+ * and last columns will not align.
+ */
+export declare function decorateTable(view: EditorView, table: SyntaxNode, ranges: Range<Decoration>[]): void;
+/** `trash`: moves a local image's file to the Recycle Bin, for its delete button (MarkdownLive passes bridge.fsTrash). */
+export declare function decorate(view: EditorView, baseDir: string, resolveWiki?: (target: string) => boolean, resolveEmbed?: (name: string) => string | null, trash?: (file: string) => Promise<void>): DecorationSet;
+export declare function livePreviewExt(baseDir: string, resolveWiki?: () => ((target: string) => boolean) | undefined, resolveEmbed?: () => ((name: string) => string | null) | undefined, trash?: (file: string) => Promise<void>): Extension;

package/types/modules/editor/viewers/live/links.d.ts

@@ -0,0 +1,16 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** `Pasted image 20261029143005.png`: the time it was pasted, to the second, as Obsidian names them. */
+export declare function pastedImageName(at: Date, mime: string): string;
+/** The link for an image saved beside the note: its name, spaces and all, encoded as a link must be. */
+export declare const imageLink: (savedPath: string) => string;
+export type LinkTarget = {
+    url: string;
+} | {
+    path: string;
+} | null;
+/**
+ * `href` from a note at `notePath`. A web or mail address as it is; a link to a heading in this
+ * note (`#part`) is nothing to open; anything else is a file: decoded (`my%20note.md`), its
+ * `#heading` dropped, and joined to the note's folder unless it is absolute.
+ */
+export declare function linkTarget(href: string, notePath: string): LinkTarget;

package/types/modules/editor/viewers/live/pasteimage.d.ts

@@ -0,0 +1,3 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** The paste handler, given the note's path (read at the paste, since a new note gets one on its first save). */
+export declare function imagePaste(notePath: () => string | undefined): import("@codemirror/state").Extension;

package/types/modules/editor/viewers/live/syntax.d.ts

@@ -0,0 +1,30 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import type { MarkdownConfig } from "@lezer/markdown";
+/**
+ * `[[Note]]`, `[[Note|alias]]`, `[[Note#heading]]` as a first-class inline node.
+ *
+ * A Lezer extension rather than a regex over the text, because CommonMark already claims the
+ * brackets: `[[Note]]` parses as a Link whose LinkMark is one bracket per side, and LinkMark is
+ * in HIDE_MARKS — so without this a wikilink renders as a literal `[Note]`. Claiming the whole
+ * `[[...]]` at PARSE time is what stops that.
+ *
+ * The alias/heading rule is the one in the Vault plugin's src/vault.ts, which is where it is tested:
+ * the alias splits on the LAST pipe, the heading on the FIRST hash of what is left.
+ */
+export declare const WikiLinkExt: MarkdownConfig;
+/**
+ * `==highlighted==`, Obsidian's marker syntax. Not part of GFM, so it needs its own rule.
+ *
+ * Two equals signs on each side, no newline between them — the same shape as Strikethrough's
+ * `~~`, which is what this is modelled on.
+ */
+export declare const HighlightExt: MarkdownConfig;
+/**
+ * `$inline$` and `$$block$$` maths, and `#tag`, as Obsidian writes them.
+ *
+ * Neither is in CommonMark or GFM, so each needs its own inline rule. The dollar rules are
+ * deliberately strict about what opens one: a lone `$` in prose ("costs $5") must not start a
+ * formula that runs to the end of the paragraph.
+ */
+export declare const MathExt: MarkdownConfig;
+export declare const TagExt: MarkdownConfig;

package/types/modules/editor/viewers/live/tableedit.d.ts

@@ -0,0 +1,20 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** One table line: its start offset and its text. */
+export interface TableLine {
+    from: number;
+    text: string;
+}
+/**
+ * The edits that add a column at the right of every line, the rule line `---`, the others empty.
+ * A line without a closing pipe gets one first, so the new cell is a cell.
+ */
+export declare function addColumn(lines: TableLine[], ruleIndex: number): {
+    from: number;
+    insert: string;
+}[];
+/** The edit that adds an empty row after the last line, as many cells wide as the header; and where its first cell's text starts. */
+export declare function addRow(lines: TableLine[]): {
+    from: number;
+    insert: string;
+    caret: number;
+};

package/types/modules/editor/viewers/live/widgets.d.ts

@@ -0,0 +1,110 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { EditorView, WidgetType } from "@codemirror/view";
+/**
+ * Obsidian's callout kinds, folded onto the handful that actually differ in appearance.
+ *
+ * Obsidian ships around a dozen names, several of which are aliases for the same colour and icon
+ * (`error` is `danger`, `tip` is `hint`). Keeping the alias table rather than a class per name
+ * means an unknown kind still renders, as a note, instead of falling back to a plain quote.
+ */
+export declare const CALLOUT_ALIAS: Record<string, string>;
+/** The glyph for each kind. Text, not an icon font — the editor has no icon set of its own. */
+export declare const CALLOUT_ICON: Record<string, string>;
+/** `[!warning]` with no title shows "Warning". */
+export declare function defaultTitle(raw: string): string;
+/** The icon and, when the callout has no title of its own, the kind's name. */
+export declare class CalloutIcon extends WidgetType {
+    readonly kind: string;
+    readonly title: string;
+    constructor(kind: string, title: string);
+    eq(o: CalloutIcon): boolean;
+    toDOM(): HTMLSpanElement;
+}
+/** A rendered KaTeX formula in place of its `$...$`. */
+export declare class MathWidget extends WidgetType {
+    readonly src: string;
+    readonly block: boolean;
+    constructor(src: string, block: boolean);
+    eq(o: MathWidget): boolean;
+    toDOM(view: EditorView): HTMLDivElement | HTMLSpanElement;
+    ignoreEvent(): boolean;
+}
+/** Load KaTeX on first use and render one formula. */
+export declare function renderMath(src: string, block: boolean): Promise<string>;
+/** Split `target#heading|alias` the way Obsidian does. See the Vault plugin's src/vault.ts. */
+export declare function splitWikiLink(body: string): {
+    target: string;
+    heading: string;
+    text: string;
+};
+export declare class BulletWidget extends WidgetType {
+    readonly ch: string;
+    constructor(ch: string);
+    eq(o: BulletWidget): boolean;
+    toDOM(): HTMLSpanElement;
+}
+export declare class TaskWidget extends WidgetType {
+    readonly checked: boolean;
+    readonly pos: number;
+    constructor(checked: boolean, pos: number);
+    eq(o: TaskWidget): boolean;
+    toDOM(view: EditorView): HTMLInputElement;
+    ignoreEvent(): boolean;
+}
+/**
+ * An inline image, with the controls Obsidian puts on one: open it full size, and drag its
+ * corner to resize.
+ *
+ * A resize writes the width back into the link itself (`![[img.png|400]]`), so it travels with
+ * the note — Obsidian shows the same width. `from`/`to`
+ * are the link's bounds so the widget can rewrite it; `width` is what it currently says.
+ */
+export declare class ImageWidget extends WidgetType {
+    readonly src: string;
+    readonly from: number;
+    readonly to: number;
+    readonly width: number | null;
+    /** Rewrite the link with a new width, or remove the width when null. */
+    readonly setWidth: (view: EditorView, from: number, to: number, width: number | null) => void;
+    /** Drawn below the revealed link text rather than in place of it. */
+    readonly below: boolean;
+    /** A file on this PC and how to put it in the Recycle Bin, for the delete button; null for a web image. */
+    readonly del: {
+        file: string;
+        trash: (file: string) => Promise<void>;
+    } | null;
+    constructor(src: string, from: number, to: number, width: number | null, 
+    /** Rewrite the link with a new width, or remove the width when null. */
+    setWidth: (view: EditorView, from: number, to: number, width: number | null) => void, 
+    /** Drawn below the revealed link text rather than in place of it. */
+    below?: boolean, 
+    /** A file on this PC and how to put it in the Recycle Bin, for the delete button; null for a web image. */
+    del?: {
+        file: string;
+        trash: (file: string) => Promise<void>;
+    } | null);
+    eq(o: ImageWidget): boolean;
+    toDOM(view: EditorView): HTMLSpanElement;
+}
+/** Show one image full size, over everything in window `win` (the editor's: a floating one too), until it is dismissed. */
+export declare function openLightbox(src: string, win: Window): void;
+/**
+ * Rewrite an image link's width in place.
+ *
+ * Both spellings: `![[file.png|400]]` for an embed and `![alt|400](path)` for a standard link,
+ * which is what Obsidian writes for each.
+ */
+export declare function writeImageWidth(view: EditorView, from: number, to: number, width: number | null): void;
+/**
+ * A table's + : at the right of its header row it adds a column, under its last row a row
+ * (tableedit.ts). The table is found from where the button is at the click, so the widget needs no
+ * position of its own and is the same widget wherever the table moves.
+ */
+export declare class TableAddWidget extends WidgetType {
+    readonly kind: "col" | "row";
+    readonly edge: boolean;
+    /** `edge`: the column + sits on its row's bottom edge, which is the table's middle when it has an even number of rows. */
+    constructor(kind: "col" | "row", edge?: boolean);
+    eq(o: TableAddWidget): boolean;
+    toDOM(view: EditorView): HTMLButtonElement;
+}