penseat 0.1.0

package/templates/components/penseat.tsx

@@ -0,0 +1,121 @@
+"use client";
+
+import { useState, useRef, useCallback, useEffect } from "react";
+import DrawingCanvas, { type DrawingCanvasHandle } from "./drawing-canvas";
+import PenseatBar, { type Corner } from "./penseat-bar";
+import { captureAndCopy } from "@/lib/capture";
+
+type Mode = "idle" | "drawing" | "capturing";
+
+export default function Penseat() {
+  const [mode, setMode] = useState<Mode>("idle");
+  const [color, setColor] = useState("#ef4444");
+  const [corner, setCorner] = useState<Corner>("rb");
+  const [shake, setShake] = useState(false);
+  const [copied, setCopied] = useState(false);
+  const shakeTimer = useRef<ReturnType<typeof setTimeout>>(null);
+  const canvasRef = useRef<DrawingCanvasHandle>(null);
+
+  const triggerShake = useCallback(() => {
+    if (shakeTimer.current) return; // previous shake still running
+    setShake(true);
+    shakeTimer.current = setTimeout(() => {
+      setShake(false);
+      shakeTimer.current = null;
+    }, 400);
+  }, []);
+
+  const toggle = useCallback(() => {
+    if (mode === "idle") {
+      setMode("drawing");
+    } else {
+      canvasRef.current?.clear();
+      setMode("idle");
+    }
+  }, [mode]);
+
+  const handleDone = useCallback(() => {
+    const canvas = canvasRef.current?.getCanvas();
+    if (!canvas) return;
+
+    if (!canvasRef.current?.hasStrokes()) {
+      triggerShake();
+      return;
+    }
+
+    // Fire clipboard.write IMMEDIATELY — must be synchronous within user activation
+    const copyPromise = captureAndCopy(canvas);
+
+    setMode("capturing");
+
+    copyPromise.then(() => {
+      setMode("drawing");
+      setCopied(true);
+      setTimeout(() => {
+        setCopied(false);
+      }, 1200);
+    }).catch((err) => {
+      console.error("Capture failed:", err);
+      triggerShake();
+      setMode("drawing");
+    });
+  }, []);
+
+  useEffect(() => {
+    const COLORS = ["#ef4444", "#eab308", "#3b82f6", "#22c55e"];
+
+    function handleKeyDown(e: KeyboardEvent) {
+      if ((e.metaKey || e.ctrlKey) && e.shiftKey && e.key === "d") {
+        e.preventDefault();
+        toggle();
+      }
+      if (e.key === "Escape" && mode === "drawing") {
+        toggle();
+      }
+      if (mode !== "drawing") return;
+
+      const isMeta = e.metaKey || e.ctrlKey;
+      if (isMeta && e.key === "c") {
+        handleDone();
+      }
+      if (isMeta && e.key === "z") {
+        e.preventDefault();
+        canvasRef.current?.undo();
+      }
+      if (!isMeta && !e.shiftKey) {
+        if (e.key === "x") canvasRef.current?.clear();
+        if (e.key === "e" || e.key === "5") setColor("#ffffff");
+        const idx = ["1", "2", "3", "4"].indexOf(e.key);
+        if (idx !== -1) setColor(COLORS[idx]);
+      }
+    }
+
+    window.addEventListener("keydown", handleKeyDown);
+    return () => window.removeEventListener("keydown", handleKeyDown);
+  }, [mode, toggle, handleDone]);
+
+  return (
+    <>
+      <DrawingCanvas
+        ref={canvasRef}
+        active={mode === "drawing" || mode === "capturing"}
+        color={color}
+      />
+
+      <PenseatBar
+        expanded={mode !== "idle"}
+        corner={corner}
+        onCornerChange={setCorner}
+        color={color}
+        onColorChange={setColor}
+        onToggle={toggle}
+        onUndo={() => canvasRef.current?.undo()}
+        onClear={() => canvasRef.current?.clear()}
+        onDone={handleDone}
+        capturing={mode === "capturing"}
+        copied={copied}
+        shake={shake}
+      />
+    </>
+  );
+}

package/templates/components/ui/button.tsx

@@ -0,0 +1,60 @@
+"use client"
+
+import { Button as ButtonPrimitive } from "@base-ui/react/button"
+import { cva, type VariantProps } from "class-variance-authority"
+
+import { cn } from "@/lib/utils"
+
+const buttonVariants = cva(
+  "group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground [a]:hover:bg-primary/80",
+        outline:
+          "border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50",
+        secondary:
+          "bg-secondary text-secondary-foreground hover:bg-secondary/80 aria-expanded:bg-secondary aria-expanded:text-secondary-foreground",
+        ghost:
+          "hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:hover:bg-muted/50",
+        destructive:
+          "bg-destructive/10 text-destructive hover:bg-destructive/20 focus-visible:border-destructive/40 focus-visible:ring-destructive/20 dark:bg-destructive/20 dark:hover:bg-destructive/30 dark:focus-visible:ring-destructive/40",
+        link: "text-primary underline-offset-4 hover:underline",
+      },
+      size: {
+        default:
+          "h-8 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2",
+        xs: "h-6 gap-1 rounded-[min(var(--radius-md),10px)] px-2 text-xs in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3",
+        sm: "h-7 gap-1 rounded-[min(var(--radius-md),12px)] px-2.5 text-[0.8rem] in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3.5",
+        lg: "h-9 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-3 has-data-[icon=inline-start]:pl-3",
+        icon: "size-8",
+        "icon-xs":
+          "size-6 rounded-[min(var(--radius-md),10px)] in-data-[slot=button-group]:rounded-lg [&_svg:not([class*='size-'])]:size-3",
+        "icon-sm":
+          "size-7 rounded-[min(var(--radius-md),12px)] in-data-[slot=button-group]:rounded-lg",
+        "icon-lg": "size-9",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default",
+    },
+  }
+)
+
+function Button({
+  className,
+  variant = "default",
+  size = "default",
+  ...props
+}: ButtonPrimitive.Props & VariantProps<typeof buttonVariants>) {
+  return (
+    <ButtonPrimitive
+      data-slot="button"
+      className={cn(buttonVariants({ variant, size, className }))}
+      {...props}
+    />
+  )
+}
+
+export { Button, buttonVariants }

package/templates/lib/capture.ts

@@ -0,0 +1,71 @@
+import html2canvas from "html2canvas-pro";
+
+/**
+ * Captures the page + drawing annotations and copies to clipboard.
+ *
+ * Key trick: ClipboardItem accepts Promise<Blob>, so we call
+ * navigator.clipboard.write() IMMEDIATELY during the user gesture,
+ * passing a promise that resolves later after html2canvas finishes.
+ * This keeps the clipboard write within the user activation window.
+ */
+export function captureAndCopy(
+  drawingCanvas: HTMLCanvasElement
+): Promise<void> {
+  // Create the async blob promise — resolved after capture completes
+  const blobPromise = captureComposite(drawingCanvas).then(
+    (composite) =>
+      new Promise<Blob>((resolve, reject) => {
+        composite.toBlob(
+          (b) =>
+            b ? resolve(b) : reject(new Error("Failed to create blob")),
+          "image/png"
+        );
+      })
+  );
+
+  // Write to clipboard IMMEDIATELY (during user gesture) with promised data
+  return navigator.clipboard.write([
+    new ClipboardItem({ "image/png": blobPromise }),
+  ]);
+}
+
+async function captureComposite(
+  drawingCanvas: HTMLCanvasElement
+): Promise<HTMLCanvasElement> {
+  // Screenshot the page DOM (visible viewport)
+  const pageCanvas = await html2canvas(document.body, {
+    useCORS: true,
+    allowTaint: true,
+    x: window.scrollX,
+    y: window.scrollY,
+    width: window.innerWidth,
+    height: window.innerHeight,
+    ignoreElements: (el) => {
+      return el.closest("[data-penseat]") !== null;
+    },
+  });
+
+  // Composite page + drawing annotations
+  const composite = document.createElement("canvas");
+  composite.width = pageCanvas.width;
+  composite.height = pageCanvas.height;
+  const ctx = composite.getContext("2d")!;
+
+  ctx.drawImage(pageCanvas, 0, 0);
+
+  // The drawing canvas is document-sized — crop visible viewport portion
+  const dpr = window.devicePixelRatio || 1;
+  ctx.drawImage(
+    drawingCanvas,
+    window.scrollX * dpr,
+    window.scrollY * dpr,
+    window.innerWidth * dpr,
+    window.innerHeight * dpr,
+    0,
+    0,
+    composite.width,
+    composite.height
+  );
+
+  return composite;
+}

package/templates/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}