nudge-ui 0.2.0 → 0.2.1

package/dist/inspector/sketch/geometry.js

@@ -0,0 +1,98 @@
+import { SKETCH_ANNOTATION_RADIUS, } from "./model.js";
+function distance(left, right) {
+    return Math.hypot(left.x - right.x, left.y - right.y);
+}
+export function distanceToSegment(point, start, end) {
+    const deltaX = end.x - start.x;
+    const deltaY = end.y - start.y;
+    const lengthSquared = deltaX * deltaX + deltaY * deltaY;
+    if (lengthSquared === 0)
+        return distance(point, start);
+    const projection = ((point.x - start.x) * deltaX + (point.y - start.y) * deltaY) / lengthSquared;
+    const position = Math.max(0, Math.min(1, projection));
+    return distance(point, {
+        x: start.x + position * deltaX,
+        y: start.y + position * deltaY,
+    });
+}
+function distanceToStroke(point, stroke) {
+    if (stroke.points.length === 1)
+        return distance(point, stroke.points[0]);
+    let closest = Number.POSITIVE_INFINITY;
+    for (let index = 1; index < stroke.points.length; index += 1) {
+        closest = Math.min(closest, distanceToSegment(point, stroke.points[index - 1], stroke.points[index]));
+    }
+    return closest;
+}
+function pointBounds(points) {
+    let minX = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (const point of points) {
+        minX = Math.min(minX, point.x);
+        maxX = Math.max(maxX, point.x);
+        minY = Math.min(minY, point.y);
+        maxY = Math.max(maxY, point.y);
+    }
+    return { minX, maxX, minY, maxY };
+}
+/** Returns the topmost drawable object under a point in canvas coordinates. */
+export function findSketchElementAt(point, strokes, annotations) {
+    for (let index = annotations.length - 1; index >= 0; index -= 1) {
+        const annotation = annotations[index];
+        if (distance(point, annotation.point) <= SKETCH_ANNOTATION_RADIUS * 1.5) {
+            return { kind: "annotation", id: annotation.id };
+        }
+    }
+    for (let index = strokes.length - 1; index >= 0; index -= 1) {
+        const stroke = strokes[index];
+        const tolerance = Math.max(10, stroke.width / 2 + 6);
+        const bounds = pointBounds(stroke.points);
+        const insideRectangle = stroke.kind === "rectangle"
+            && point.x >= bounds.minX - tolerance
+            && point.x <= bounds.maxX + tolerance
+            && point.y >= bounds.minY - tolerance
+            && point.y <= bounds.maxY + tolerance;
+        if (insideRectangle || distanceToStroke(point, stroke) <= tolerance) {
+            return { kind: "stroke", id: stroke.id };
+        }
+    }
+    return null;
+}
+function constrainedDelta(points, delta, bounds) {
+    if (points.length === 0)
+        return delta;
+    const { minX, maxX, minY, maxY } = pointBounds(points);
+    let x = delta.x;
+    let y = delta.y;
+    if (minX + x < 0)
+        x = -minX;
+    else if (maxX + x > bounds.width)
+        x = bounds.width - maxX;
+    if (minY + y < 0)
+        y = -minY;
+    else if (maxY + y > bounds.height)
+        y = bounds.height - maxY;
+    return { x, y };
+}
+export function translateSketchStroke(stroke, delta, bounds) {
+    const constrained = constrainedDelta(stroke.points, delta, bounds);
+    return {
+        ...stroke,
+        points: stroke.points.map((point) => ({
+            x: point.x + constrained.x,
+            y: point.y + constrained.y,
+        })),
+    };
+}
+export function translateSketchAnnotation(annotation, delta, bounds) {
+    const constrained = constrainedDelta([annotation.point], delta, bounds);
+    return {
+        ...annotation,
+        point: {
+            x: annotation.point.x + constrained.x,
+            y: annotation.point.y + constrained.y,
+        },
+    };
+}

package/dist/inspector/sketch/handoff.d.ts

@@ -0,0 +1,21 @@
+import type { AgentSketchAttachment, AgentSketchMetadata } from "../agent/protocol.js";
+import { type SketchQueueItem } from "./model.js";
+export interface SketchHandoffEntry {
+    readonly id: string;
+    readonly revision: number;
+    readonly metadata: AgentSketchMetadata;
+    readonly annotatedImage: Blob;
+}
+export interface SketchClipboardHandoffSnapshot {
+    readonly localBatchId: string;
+    readonly entries: readonly SketchHandoffEntry[];
+}
+export declare function createSketchHandoffSnapshot(items: readonly SketchQueueItem[]): SketchClipboardHandoffSnapshot | null;
+export declare function createSketchAttachments(handoff: SketchClipboardHandoffSnapshot): Promise<AgentSketchAttachment[]>;
+export declare function sketchMetadataForHandoff(handoff: SketchClipboardHandoffSnapshot | null): readonly AgentSketchMetadata[];
+export declare function getSketchClipboardHandoffSnapshot(): SketchClipboardHandoffSnapshot | null;
+export declare function subscribeSketchClipboardHandoff(listener: () => void): () => void;
+export declare function useSketchClipboardHandoff(): SketchClipboardHandoffSnapshot | null;
+export declare function recordSketchClipboardHandoff(snapshot: SketchClipboardHandoffSnapshot | null): void;
+export declare function clearSketchClipboardHandoff(): void;
+export declare function resetSketchClipboardHandoff(): void;

package/dist/inspector/sketch/handoff.js

@@ -0,0 +1,72 @@
+import { useSyncExternalStore } from "react";
+import { blobToBase64 } from "./raster.js";
+import { toAgentSketchMetadata } from "./model.js";
+const EMPTY_HANDOFF = null;
+let handoffSnapshot = EMPTY_HANDOFF;
+const listeners = new Set();
+function notify() {
+    for (const listener of listeners) {
+        try {
+            listener();
+        }
+        catch {
+            // A handoff view must not prevent other subscribers from updating.
+        }
+    }
+}
+function randomId() {
+    try {
+        if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function")
+            return crypto.randomUUID();
+    }
+    catch {
+        // Use the fallback below.
+    }
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+export function createSketchHandoffSnapshot(items) {
+    if (items.length === 0)
+        return null;
+    return {
+        localBatchId: randomId(),
+        entries: items.map((item) => ({
+            id: item.document.id,
+            revision: item.document.revision,
+            metadata: toAgentSketchMetadata(item.document),
+            annotatedImage: item.document.annotatedImage,
+        })),
+    };
+}
+export function createSketchAttachments(handoff) {
+    return Promise.all(handoff.entries.map(async (entry) => ({
+        ...entry.metadata,
+        data: await blobToBase64(entry.annotatedImage),
+    })));
+}
+export function sketchMetadataForHandoff(handoff) {
+    return handoff?.entries.map((entry) => entry.metadata) ?? [];
+}
+export function getSketchClipboardHandoffSnapshot() {
+    return handoffSnapshot;
+}
+export function subscribeSketchClipboardHandoff(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+export function useSketchClipboardHandoff() {
+    return useSyncExternalStore(subscribeSketchClipboardHandoff, getSketchClipboardHandoffSnapshot, getSketchClipboardHandoffSnapshot);
+}
+export function recordSketchClipboardHandoff(snapshot) {
+    handoffSnapshot = snapshot;
+    notify();
+}
+export function clearSketchClipboardHandoff() {
+    if (handoffSnapshot === null)
+        return;
+    handoffSnapshot = null;
+    notify();
+}
+export function resetSketchClipboardHandoff() {
+    handoffSnapshot = null;
+    notify();
+}

package/dist/inspector/sketch/interaction.d.ts

@@ -0,0 +1,21 @@
+import { type CapturedSketch } from "./capture.js";
+export type SketchCaptureState = "idle" | "sketching" | "capturing" | "ready" | "error";
+export type SketchEntryTool = "pen" | "annotate";
+export interface SketchInteractionSnapshot {
+    readonly captureState: SketchCaptureState;
+    readonly captured: CapturedSketch | null;
+    readonly editingId: string | null;
+    readonly error: string | null;
+    readonly initialTool: SketchEntryTool;
+}
+export declare function getSketchInteractionSnapshot(): SketchInteractionSnapshot;
+export declare function subscribeSketchInteraction(listener: () => void): () => void;
+export declare function useSketchInteraction(): SketchInteractionSnapshot;
+export declare function isSketchInteractionActive(): boolean;
+export declare function useSketchInteractionActive(): boolean;
+export declare function beginSketchCapture(initialTool?: SketchEntryTool): void;
+export declare function completeSketchCapture(hostElement: HTMLElement): Promise<CapturedSketch>;
+export declare function cancelSketchInteraction(): void;
+export declare function openSketchEditor(sketchId: string): void;
+export declare function closeSketchEditor(): void;
+export declare function resetSketchInteraction(): void;

package/dist/inspector/sketch/interaction.js

@@ -0,0 +1,98 @@
+import { useSyncExternalStore } from "react";
+import { captureViewport, } from "./capture.js";
+const EMPTY_SNAPSHOT = {
+    captureState: "idle",
+    captured: null,
+    editingId: null,
+    error: null,
+    initialTool: "pen",
+};
+let snapshot = EMPTY_SNAPSHOT;
+let captureController = null;
+const listeners = new Set();
+function publish(next) {
+    snapshot = next;
+    for (const listener of listeners) {
+        try {
+            listener();
+        }
+        catch {
+            // A view subscriber must not break the interaction state machine.
+        }
+    }
+}
+export function getSketchInteractionSnapshot() {
+    return snapshot;
+}
+export function subscribeSketchInteraction(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+export function useSketchInteraction() {
+    return useSyncExternalStore(subscribeSketchInteraction, getSketchInteractionSnapshot, getSketchInteractionSnapshot);
+}
+export function isSketchInteractionActive() {
+    return snapshot.captureState !== "idle" || snapshot.captured !== null || snapshot.editingId !== null;
+}
+export function useSketchInteractionActive() {
+    const current = useSketchInteraction();
+    return current.captureState !== "idle" || current.captured !== null || current.editingId !== null;
+}
+export function beginSketchCapture(initialTool = "pen") {
+    captureController?.abort();
+    captureController = null;
+    publish({ captureState: "sketching", captured: null, editingId: null, error: null, initialTool });
+}
+export function completeSketchCapture(hostElement) {
+    captureController?.abort();
+    const controller = new AbortController();
+    captureController = controller;
+    const initialTool = snapshot.initialTool;
+    publish({ captureState: "capturing", captured: null, editingId: null, error: null, initialTool });
+    const options = { hostElement, signal: controller.signal };
+    return captureViewport(options)
+        .then((captured) => {
+        if (captureController !== controller)
+            return captured;
+        captureController = null;
+        publish({ captureState: "ready", captured, editingId: null, error: null, initialTool });
+        return captured;
+    })
+        .catch((error) => {
+        if (captureController !== controller)
+            throw error;
+        captureController = null;
+        if (controller.signal.aborted) {
+            publish(EMPTY_SNAPSHOT);
+            throw error;
+        }
+        publish({
+            captureState: "error",
+            captured: null,
+            editingId: null,
+            error: error instanceof Error ? error.message : "The viewport could not be captured.",
+            initialTool,
+        });
+        throw error;
+    });
+}
+export function cancelSketchInteraction() {
+    captureController?.abort();
+    captureController = null;
+    publish(EMPTY_SNAPSHOT);
+}
+export function openSketchEditor(sketchId) {
+    captureController?.abort();
+    captureController = null;
+    publish({ captureState: "idle", captured: null, editingId: sketchId, error: null, initialTool: "pen" });
+}
+export function closeSketchEditor() {
+    if (snapshot.captureState !== "ready" && snapshot.editingId === null)
+        return;
+    publish(EMPTY_SNAPSHOT);
+}
+export function resetSketchInteraction() {
+    captureController?.abort();
+    captureController = null;
+    snapshot = EMPTY_SNAPSHOT;
+}

package/dist/inspector/sketch/model.d.ts

@@ -0,0 +1,104 @@
+import type { AgentSketchCaptureMetadata, AgentSketchMetadata } from "../agent/protocol.js";
+export declare const SKETCH_SCHEMA_VERSION: 1;
+export declare const SKETCH_DATABASE_NAME = "nudge-ui-sketches";
+export declare const SKETCH_DATABASE_VERSION = 1;
+export declare const SKETCH_DOCUMENTS_STORE = "documents";
+export declare const SKETCH_HANDOFFS_STORE = "handoffs";
+export declare const SKETCH_LIMITS: {
+    readonly completedSketches: 4;
+    readonly imageEdge: 2048;
+    readonly imageBytes: number;
+    readonly projectBytes: number;
+    readonly strokes: 500;
+    readonly points: 20000;
+    readonly annotations: 50;
+    readonly description: 2000;
+    readonly url: 2048;
+    readonly title: 512;
+};
+export declare const SKETCH_STROKE_WIDTH = 6;
+export declare const SKETCH_STROKE_COLOR = "#0096ff";
+export declare const SKETCH_STROKE_OUTLINE = "";
+export declare const SKETCH_ANNOTATION_RADIUS = 16;
+declare const LEGACY_SKETCH_STROKE_COLOR = "#ef4444";
+declare const LEGACY_SKETCH_STROKE_OUTLINE = "#111827";
+export type SketchStatus = "pending" | "dispatching" | "handing-off" | "needs-review" | "unknown";
+export type SketchTransport = "local" | "clipboard" | "direct";
+export type SketchHandoffState = SketchStatus;
+export interface SketchPoint {
+    readonly x: number;
+    readonly y: number;
+}
+type SketchStrokeColor = typeof SKETCH_STROKE_COLOR | typeof LEGACY_SKETCH_STROKE_COLOR;
+type SketchStrokeOutline = typeof SKETCH_STROKE_OUTLINE | typeof LEGACY_SKETCH_STROKE_OUTLINE;
+export type SketchStrokeKind = "freehand" | "rectangle";
+export interface SketchStroke {
+    readonly id: string;
+    /** Optional for compatibility with strokes saved before movable layers. */
+    readonly kind?: SketchStrokeKind;
+    readonly width: number;
+    readonly color: SketchStrokeColor;
+    readonly outlineColor: SketchStrokeOutline;
+    readonly points: readonly SketchPoint[];
+}
+export interface SketchAnnotation {
+    readonly id: string;
+    readonly number: number;
+    readonly point: SketchPoint;
+    readonly description: string;
+}
+export interface SketchCaptureMetadata extends AgentSketchCaptureMetadata {
+    readonly imageWidth: number;
+    readonly imageHeight: number;
+}
+export interface SketchDocument {
+    readonly schemaVersion: typeof SKETCH_SCHEMA_VERSION;
+    readonly projectId: string;
+    readonly id: string;
+    readonly revision: number;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly capture: SketchCaptureMetadata;
+    readonly description: string;
+    readonly strokes: readonly SketchStroke[];
+    /** Optional for compatibility with sketches saved before annotations existed. */
+    readonly annotations?: readonly SketchAnnotation[];
+    readonly imageWidth: number;
+    readonly imageHeight: number;
+    readonly originalByteSize: number;
+    readonly annotatedByteSize: number;
+    readonly filename: string;
+    readonly originalImage: Blob;
+    readonly annotatedImage: Blob;
+}
+export interface SketchHandoffRecord {
+    readonly id: string;
+    readonly projectId: string;
+    readonly sketchId: string;
+    readonly sketchRevision: number;
+    readonly localBatchId: string;
+    readonly batchRevision?: number;
+    readonly transport: SketchTransport;
+    readonly agentRequestId?: string;
+    readonly timestamp: number;
+    readonly state: SketchHandoffState;
+}
+export interface SketchQueueItem {
+    readonly document: SketchDocument;
+    readonly handoff: SketchHandoffRecord | null;
+    readonly status: SketchStatus;
+}
+export declare function createSketchFilename(id: string, revision: number): string;
+export declare function isFiniteNumber(value: unknown): value is number;
+export declare function isSketchCaptureMetadata(value: unknown): value is SketchCaptureMetadata;
+export declare function isSketchPoint(value: unknown): value is SketchPoint;
+export declare function isSketchAnnotation(value: unknown): value is SketchAnnotation;
+export declare function isSketchStroke(value: unknown): value is SketchStroke;
+export declare function isSketchDocument(value: unknown): value is SketchDocument;
+export declare function isSketchHandoffRecord(value: unknown): value is SketchHandoffRecord;
+export declare function cloneSketchDocument(document: SketchDocument): SketchDocument;
+export declare function cloneSketchHandoff(handoff: SketchHandoffRecord): SketchHandoffRecord;
+export declare function sketchContentFingerprint(description: string, strokes: readonly SketchStroke[], annotations?: readonly SketchAnnotation[]): string;
+export declare function sameSketchContent(document: Pick<SketchDocument, "description" | "strokes" | "annotations">, description: string, strokes: readonly SketchStroke[], annotations?: readonly SketchAnnotation[]): boolean;
+export declare function toAgentSketchMetadata(document: SketchDocument): AgentSketchMetadata;
+export {};