@opentui/core 0.5.0 → 0.5.2

package/lib/clipboard.d.ts

@@ -1,10 +1,129 @@
 import type { RendererHandle, RenderLib } from "../zig.js";
+export interface ClipboardRepresentation {
+    readonly mimeType: string;
+    readonly bytes: Uint8Array;
+}
+export type ClipboardSelection = "clipboard" | "primary";
+export interface ClipboardReadOptions {
+    readonly preferredTypes: readonly [string, ...string[]];
+    readonly selection?: ClipboardSelection;
+    readonly signal?: AbortSignal;
+}
+export type ClipboardReadResult = {
+    readonly status: "read";
+    readonly representation: ClipboardRepresentation;
+} | {
+    readonly status: "empty" | "unsupported" | "cancelled" | "timed-out" | "limit-exceeded";
+} | {
+    readonly status: "failed";
+    readonly error: Error;
+};
+export interface HostClipboardReadOptions {
+    readonly preferredTypes: readonly [string, ...string[]];
+    readonly selection: ClipboardSelection;
+    readonly maxBytes: number;
+    readonly timeoutMs: number;
+    readonly signal: AbortSignal;
+}
+export interface HostClipboardWriteOptions {
+    readonly selection: ClipboardSelection;
+    readonly timeoutMs: number;
+    readonly signal: AbortSignal;
+}
+export type HostClipboardWriteResult = {
+    readonly status: "written" | "unsupported" | "cancelled" | "timed-out";
+} | {
+    readonly status: "failed";
+    readonly error: Error;
+};
+export type HostClipboardClearResult = {
+    readonly status: "cleared" | "unsupported" | "cancelled" | "timed-out";
+} | {
+    readonly status: "failed";
+    readonly error: Error;
+};
+export interface HostClipboardBackend {
+    read(options: HostClipboardReadOptions): Promise<ClipboardReadResult>;
+    writeText(text: string, options: HostClipboardWriteOptions): Promise<HostClipboardWriteResult>;
+    clear(options: HostClipboardWriteOptions): Promise<HostClipboardClearResult>;
+    dispose(): Promise<void>;
+}
+export type ClipboardWriteDestination = "terminal-only" | "host-only" | "best-available" | "all-available";
+export interface ClipboardWriteOptions {
+    readonly destination: ClipboardWriteDestination;
+    readonly selection?: ClipboardSelection;
+    readonly allowRemoteHost?: boolean;
+    readonly signal?: AbortSignal;
+}
+export interface TerminalClipboardOperationResult {
+    readonly status: "attempted" | "local-failure" | "not-attempted";
+    readonly capability: "supported" | "unsupported" | "unknown";
+}
+export interface ClipboardWriteResult {
+    readonly host: HostClipboardWriteResult | {
+        readonly status: "not-attempted";
+    };
+    readonly terminal: TerminalClipboardOperationResult;
+}
+export interface ClipboardClearResult {
+    readonly host: HostClipboardClearResult | {
+        readonly status: "not-attempted";
+    };
+    readonly terminal: TerminalClipboardOperationResult;
+}
+export interface ClipboardService {
+    read(options: ClipboardReadOptions): Promise<ClipboardReadResult>;
+    writeText(text: string, options: ClipboardWriteOptions): Promise<ClipboardWriteResult>;
+    clear(options: ClipboardWriteOptions): Promise<ClipboardClearResult>;
+    dispose(): Promise<void>;
+}
+export interface HostClipboardOperationOptions {
+    readonly selection?: ClipboardSelection;
+    readonly signal?: AbortSignal;
+}
+export interface HostClipboardService {
+    readonly maxWriteBytes: number;
+    read(options: ClipboardReadOptions): Promise<ClipboardReadResult>;
+    writeText(text: string, options?: HostClipboardOperationOptions): Promise<HostClipboardWriteResult>;
+    clear(options?: HostClipboardOperationOptions): Promise<HostClipboardClearResult>;
+    dispose(): Promise<void>;
+}
+export interface HostClipboardOptions {
+    readonly timeoutMs?: number;
+    readonly maxReadBytes?: number;
+    readonly maxWriteBytes?: number;
+    readonly maxImagePixels?: number;
+    readonly maxConversionBytes?: number;
+    readonly maxConcurrentOperations?: number;
+    readonly maxProviderTransfers?: number;
+    readonly waylandSeat?: string;
+}
+export interface TerminalClipboardAdapter {
+    readonly remote: boolean;
+    writeText(text: string, selection: ClipboardSelection): TerminalClipboardOperationResult;
+    clear(selection: ClipboardSelection): TerminalClipboardOperationResult;
+}
+export interface ClipboardOptions {
+    readonly host: HostClipboardService;
+    readonly terminal: TerminalClipboardAdapter;
+}
+export declare const createHostClipboard: (options?: HostClipboardOptions) => HostClipboardService;
+export declare const createClipboard: ({ host, terminal }: ClipboardOptions) => ClipboardService;
 export declare enum ClipboardTarget {
     Clipboard = 0,
     Primary = 1,
     Select = 2,
     Secondary = 3
 }
+export interface RendererClipboardBoundary {
+    readonly capabilities: {
+        readonly remote: boolean;
+        readonly osc52_support: "supported" | "unsupported" | "unknown";
+    } | null;
+    copyToClipboardOSC52(text: string, target?: ClipboardTarget): boolean;
+    clearClipboardOSC52(target?: ClipboardTarget): boolean;
+}
+export declare const createRendererClipboardAdapter: (renderer: RendererClipboardBoundary) => TerminalClipboardAdapter;
 export declare class Clipboard {
     private lib;
     private rendererPtr;

package/lib/host-clipboard.internal.d.ts

@@ -0,0 +1,22 @@
+import type { HostClipboardBackend, HostClipboardOptions, HostClipboardService } from "./clipboard.js";
+export declare const HOST_CLIPBOARD_MIME_PREFERENCE_COUNT_MAX = 64;
+export declare const HOST_CLIPBOARD_MIME_ESSENCE_BYTES_MAX = 255;
+export interface NormalizedHostClipboardOptions {
+    readonly timeoutMs: number;
+    readonly maxReadBytes: number;
+    readonly maxWriteBytes: number;
+    readonly maxImagePixels: number;
+    readonly maxConversionBytes: number;
+    readonly maxConcurrentOperations: number;
+    readonly maxProviderTransfers: number;
+    readonly waylandSeat?: string;
+}
+export type HostClipboardBackendFactory = (options: NormalizedHostClipboardOptions) => HostClipboardBackend;
+export interface ActiveClipboardOperation {
+    readonly controller: AbortController;
+    readonly settled: Promise<void>;
+    settle(): void;
+}
+export declare const validateClipboardText: (text: string, maxWriteBytes: number) => void;
+export declare const runTrackedOperation: <T>(active: Set<ActiveClipboardOperation>, callerSignal: AbortSignal | undefined, operation: (signal: AbortSignal) => Promise<T>) => Promise<T>;
+export declare const createHostClipboardWithBackend: (options: HostClipboardOptions, createBackend: HostClipboardBackendFactory) => HostClipboardService;

package/lib/host-clipboard.native.d.ts

@@ -0,0 +1,2 @@
+import { type HostClipboardBackendFactory } from "./host-clipboard.internal.js";
+export declare const createNativeHostClipboardBackend: HostClipboardBackendFactory;

package/lib/tree-sitter/types.d.ts

@@ -142,6 +142,7 @@ export type TreeSitterWorkerResponse = {
 } | {
     type: "ERROR";
     bufferId?: number;
+    messageId?: string;
     error: string;
 } | {
     type: "WORKER_LOG";

package/package.json

@@ -4,7 +4,7 @@
   "main": "index.node.js",
   "types": "index.d.ts",
   "type": "module",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "OpenTUI is a TypeScript library on a native Zig core for building terminal user interfaces (TUIs)",
   "license": "MIT",
   "repository": {
@@ -75,13 +75,13 @@
     "web-tree-sitter": "0.25.10"
   },
   "optionalDependencies": {
-    "@opentui/core-darwin-x64": "0.5.0",
-    "@opentui/core-darwin-arm64": "0.5.0",
-    "@opentui/core-linux-x64": "0.5.0",
-    "@opentui/core-linux-arm64": "0.5.0",
-    "@opentui/core-win32-x64": "0.5.0",
-    "@opentui/core-win32-arm64": "0.5.0",
-    "@opentui/core-linux-x64-musl": "0.5.0",
-    "@opentui/core-linux-arm64-musl": "0.5.0"
+    "@opentui/core-darwin-x64": "0.5.2",
+    "@opentui/core-darwin-arm64": "0.5.2",
+    "@opentui/core-linux-x64": "0.5.2",
+    "@opentui/core-linux-arm64": "0.5.2",
+    "@opentui/core-win32-x64": "0.5.2",
+    "@opentui/core-win32-arm64": "0.5.2",
+    "@opentui/core-linux-x64-musl": "0.5.2",
+    "@opentui/core-linux-arm64-musl": "0.5.2"
   }
 }

package/parser.worker.js

@@ -4406,10 +4406,11 @@ function logMessage(type, ...args2) {
     data: args2
   });
 }
-function postWorkerError(bufferId, error) {
+function postWorkerError(bufferId, messageId, error) {
   postWorkerMessage({
     type: "ERROR",
     bufferId,
+    messageId,
     error: error instanceof Error ? error.stack || error.message : String(error)
   });
 }
@@ -4551,14 +4552,15 @@ if (isWorkerRuntime) {
           });
       }
     } catch (error) {
+      const messageId = "messageId" in message ? message.messageId : undefined;
       if ("bufferId" in message) {
-        postWorkerError(message.bufferId, error);
+        postWorkerError(message.bufferId, messageId, error);
       } else {
-        postWorkerError(undefined, error);
+        postWorkerError(undefined, messageId, error);
       }
     }
   });
 }
 
-//# debugId=E5F8B2FE3F70793464756E2164756E21
+//# debugId=E1AC0FF95C96198464756E2164756E21
 //# sourceMappingURL=parser.worker.js.map