lineadraw 0.8.0 → 0.9.0

package/dist/bridge.d.ts

@@ -0,0 +1,102 @@
+declare const DEFAULT_BRIDGE_PORT = 7431;
+/** A running editor as the bridge lists it. */
+interface EditorInfo {
+    /** The drawing's document id — the stable way to address it. */
+    id: string;
+    name: string;
+    /** The file it is bound to; absent for an unsaved drawing / a web tab. */
+    path?: string | null;
+    kind: "desktop" | "web";
+    readOnly: boolean;
+    /** Changed since the last file save. */
+    dirty: boolean;
+}
+/** `GET /status`: the app's version, the bridge port, the open editors. */
+interface BridgeStatus {
+    version: string;
+    port: number;
+    editors: EditorInfo[];
+}
+interface BridgeOptions {
+    /** Default: bridge.json's port, else 7431. */
+    port?: number;
+    /** Agent token, when the app requires one. Default: LINEA_BRIDGE_TOKEN,
+     * else bridge.json's token. */
+    token?: string;
+    /** The bridge.json to read, or `false` to read none. Default: the
+     * desktop app's own (per-OS app-data folder). */
+    bridgeFile?: string | false;
+    /** Injected fetch (tests, proxies). Default: the global one. */
+    fetch?: typeof fetch;
+}
+/** A bridge or editor refusal: `code` is the bridge's (`ambiguous`,
+ * `noSuchEditor`, `readOnly`, `validation`, `fileNotFound`…). */
+declare class BridgeError extends Error {
+    readonly code?: string;
+    readonly status?: number;
+    /** The rest of the error body (e.g. `candidates` for `ambiguous`). */
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, opts?: {
+        code?: string;
+        status?: number;
+        details?: Record<string, unknown>;
+        cause?: unknown;
+    });
+}
+/** The desktop app's bridge.json path on this OS. */
+declare const bridgeFilePath: () => string;
+/** One editor, addressed by document id, file path or (unique) name. */
+interface EditorHandle {
+    /** How this handle addresses the editor. */
+    readonly ref: string;
+    /** Run one `linea_*` operation; resolves its result. */
+    call<T = unknown>(operation: string, args?: Record<string, unknown>): Promise<T>;
+    /**
+     * Run a `defineCommand` module inside the editor as ONE undo step —
+     * loops, reads and edits against the full Drawing API, one round trip.
+     * `inputs` / `params` answer the module's declared ones (the user is
+     * never asked).
+     */
+    runScript<T = unknown>(source: string, opts?: {
+        inputs?: readonly (readonly [number, number])[];
+        params?: Record<string, unknown>;
+    }): Promise<T>;
+    /** Close it like its window's x; a dirty desktop drawing is refused
+     * unless `discard`. */
+    close(opts?: {
+        discard?: boolean;
+    }): Promise<unknown>;
+}
+/** The running app: its editors and the operations they offer. */
+interface LineaBridge {
+    /** The bridge's address, e.g. http://127.0.0.1:7431. */
+    readonly url: string;
+    status(): Promise<BridgeStatus>;
+    /** The open editors. */
+    editors(): Promise<EditorInfo[]>;
+    /** The operations the bridge offers (name + description). */
+    tools(): Promise<{
+        name: string;
+        description?: string;
+    }[]>;
+    /** Open a `.linea` file in a window of its own (an absolute path, or one
+     * relative to the current directory); resolves once it has loaded. */
+    open(path: string): Promise<EditorInfo>;
+    /** A handle on one editor (id, path or unique name). Omitted: the only
+     * open editor — with several, calls fail as `ambiguous`. */
+    editor(ref?: string): EditorHandle;
+    /** One operation on an editor (`editor` as for `editor()`). */
+    call<T = unknown>(operation: string, args?: Record<string, unknown>, opts?: {
+        editor?: string;
+    }): Promise<T>;
+}
+/**
+ * Connect to the running Linea desktop app's bridge: reads its bridge.json
+ * (port, agent token), checks that it answers, and returns the client.
+ * Rejects with a BridgeError when nothing answers.
+ */
+declare const connectEditors: (opts?: BridgeOptions) => Promise<LineaBridge>;
+/** The client without the reachability check (the CLI's one-shot calls). */
+declare const createBridge: (opts?: BridgeOptions) => LineaBridge;
+
+export { BridgeError, type BridgeOptions, type BridgeStatus, DEFAULT_BRIDGE_PORT, type EditorHandle, type EditorInfo, type LineaBridge, bridgeFilePath, connectEditors, createBridge };

package/dist/bridge.js

@@ -0,0 +1,16 @@
+import {
+  BridgeError,
+  DEFAULT_BRIDGE_PORT,
+  bridgeFilePath,
+  connectEditors,
+  createBridge
+} from "./chunk-L2CWZAKW.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  BridgeError,
+  DEFAULT_BRIDGE_PORT,
+  bridgeFilePath,
+  connectEditors,
+  createBridge
+};
+//# sourceMappingURL=bridge.js.map