@medeo-plugin/plugin-screenshot 1.0.0 → 1.0.2

package/src/src/protocol.ts

@@ -0,0 +1,53 @@
+// Messages between the worker and the two windows (overlay editor, settings). The channel
+// broadcasts to every window of the plugin, so each message names who it is for.
+import type { Rect } from './geometry.ts';
+import type { Settings, ShortcutKey } from './settings.ts';
+
+/** area: select then edit · quick: save/copy as soon as the selection is made · ocr: read text · full: whole display. */
+export type Mode = 'area' | 'quick' | 'ocr' | 'full';
+export type Action = 'copy' | 'save' | 'ocr';
+export interface Output { format: 'png' | 'jpeg'; downscale: boolean; enter: 'copy' | 'save' }
+
+/** One captured display: `width`/`height` in points, the PNG is `width*scale` pixels wide. */
+export interface Shot { seq: number; mode: Mode; width: number; height: number; scale: number; windows: Rect[]; output: Output }
+export interface OcrResult { text: string; codes: string[] }
+
+export type ToOverlay =
+  | { type: 'shot'; shot: Shot; parts: number }
+  | { type: 'chunk'; seq: number; i: number; data: string }
+  | { type: 'ocr'; seq: number; result: OcrResult | null }
+  | { type: 'overlay-toast'; key: string; params?: Record<string, string> };
+
+export type FromOverlay =
+  | { type: 'overlay-ready' }
+  | { type: 'result'; seq: number; action: Action; mime: string; i: number; parts: number; data: string }
+  | { type: 'cancel'; seq: number }
+  | { type: 'copy-text'; text: string }
+  | { type: 'open-url'; url: string };
+
+export interface SettingsState { settings: Settings; saveDir: string; errors: Partial<Record<ShortcutKey, string>> }
+
+export type ToSettings = { type: 'settings'; state: SettingsState } | { type: 'toast'; tone: 'success' | 'error'; key: string };
+
+export type FromSettings =
+  | { type: 'settings-ready' }
+  | { type: 'set'; patch: Partial<Settings> }
+  | { type: 'choose-folder' }
+  | { type: 'reveal-folder' }
+  | { type: 'open-privacy' }
+  | { type: 'capture' };
+
+/** Under the 1 MiB channel limit with room for the envelope. */
+export const CHUNK = 768 * 1024;
+export const split = (b64: string) => { const out: string[] = []; for (let i = 0; i < b64.length; i += CHUNK) out.push(b64.slice(i, i + CHUNK)); return out.length ? out : ['']; };
+
+/** Vision observations (normalized, bottom-left origin) → reading order, one text line per row. */
+export function joinLines(lines: { t: string; x: number; y: number; h: number }[]): string {
+  const sorted = [...lines].sort((a, b) => (b.y + b.h / 2) - (a.y + a.h / 2));
+  const rows: { y: number; h: number; items: typeof lines }[] = [];
+  for (const l of sorted) {
+    const mid = l.y + l.h / 2, row = rows.find(r => Math.abs(r.y - mid) < Math.min(r.h, l.h) * 0.5);
+    if (row) row.items.push(l); else rows.push({ y: mid, h: l.h, items: [l] });
+  }
+  return rows.map(r => r.items.sort((a, b) => a.x - b.x).map(i => i.t).join(' ')).join('\n');
+}

package/src/src/settings.ts

@@ -0,0 +1,48 @@
+// Settings live in the plugin's private storagePath/settings.json; bad values fall back to defaults.
+import { valid } from './shortcuts.ts';
+
+export const SHORTCUTS = ['shortcutArea', 'shortcutFull', 'shortcutQuick', 'shortcutOcr'] as const;
+export type ShortcutKey = typeof SHORTCUTS[number];
+
+export interface Settings {
+  /** Accelerators; null = no shortcut. Only area capture has one by default (⌘⇧X). */
+  shortcutArea: string | null;
+  shortcutFull: string | null;
+  shortcutQuick: string | null;
+  shortcutOcr: string | null;
+  /** What ↩ (and quick capture) does. */
+  enterAction: 'copy' | 'save';
+  format: 'png' | 'jpeg';
+  /** Save Retina captures at 1× (half the pixels). */
+  downscale: boolean;
+  /** `~/…` or absolute. */
+  saveDir: string;
+  openAfterSave: boolean;
+}
+export const DEFAULTS: Settings = {
+  shortcutArea: 'Command+Shift+X', shortcutFull: null, shortcutQuick: null, shortcutOcr: null,
+  enterAction: 'copy', format: 'png', downscale: false, saveDir: '~/Pictures/Medeo Screenshots', openAfterSave: false,
+};
+
+const shortcut = (v: unknown, d: string | null) => v === null ? null : typeof v === 'string' && valid(v) ? v : d;
+
+export function normalize(value: unknown): Settings {
+  const v = value && typeof value === 'object' ? value as Record<string, unknown> : {};
+  const out = { ...DEFAULTS };
+  // Earlier versions stored a single capture shortcut.
+  const legacy = Object.hasOwn(v, 'shortcutCapture') && !Object.hasOwn(v, 'shortcutArea') ? { shortcutArea: v.shortcutCapture } : {};
+  const all = { ...v, ...legacy } as Record<string, unknown>;
+  const seen = new Set<string>();
+  for (const k of SHORTCUTS) {
+    const s = Object.hasOwn(all, k) ? shortcut(all[k], DEFAULTS[k]) : DEFAULTS[k];
+    // One key never does two things: a later duplicate is dropped.
+    out[k] = s && seen.has(s.toLowerCase()) ? null : s;
+    if (out[k]) seen.add(out[k]!.toLowerCase());
+  }
+  if (v.enterAction === 'copy' || v.enterAction === 'save') out.enterAction = v.enterAction;
+  if (v.format === 'png' || v.format === 'jpeg') out.format = v.format;
+  if (typeof v.downscale === 'boolean') out.downscale = v.downscale;
+  if (typeof v.saveDir === 'string' && v.saveDir.trim() && v.saveDir.length < 1024) out.saveDir = v.saveDir.trim();
+  if (typeof v.openAfterSave === 'boolean') out.openAfterSave = v.openAfterSave;
+  return out;
+}

package/src/src/shortcuts.ts

@@ -0,0 +1,25 @@
+// Recording keys into Electron accelerators and showing them (after Window Ring). No SDK.
+const MODIFIERS = ['Control', 'Alt', 'Shift', 'Command'] as const;
+const SYMBOLS: Record<string, string> = { Control: '⌃', Alt: '⌥', Shift: '⇧', Command: '⌘', Left: '←', Right: '→', Up: '↑', Down: '↓', Enter: '↩', Space: 'Space', Backspace: '⌫', Tab: '⇥' };
+const PUNCTUATION: Record<string, string> = { Minus: '-', Equal: '=', BracketLeft: '[', BracketRight: ']', Semicolon: ';', Quote: "'", Comma: ',', Period: '.', Slash: '/', Backslash: '\\', Backquote: '`' };
+const NAMED: Record<string, string> = { ArrowLeft: 'Left', ArrowRight: 'Right', ArrowUp: 'Up', ArrowDown: 'Down', Enter: 'Enter', NumpadEnter: 'Enter', Space: 'Space', Backspace: 'Backspace', Tab: 'Tab' };
+
+const canonical = (accelerator: string) => { const parts = accelerator.split('+'), key = parts.pop()!; return [...MODIFIERS.filter(m => parts.includes(m)), key].join('+'); };
+export const same = (a: string, b: string) => canonical(a).toLowerCase() === canonical(b).toLowerCase();
+
+/** One non-modifier key plus ⌃, ⌥ or ⌘ (⇧ alone would eat ordinary typing); F-keys may stand alone. */
+export function valid(accelerator: string): boolean {
+  const parts = accelerator.split('+'), key = parts.pop();
+  if (!key || (MODIFIERS as readonly string[]).includes(key)) return false;
+  if (parts.some(p => !(MODIFIERS as readonly string[]).includes(p)) || new Set(parts).size !== parts.length) return false;
+  return /^F(?:[1-9]|1\d|20)$/.test(key) || parts.some(p => p !== 'Shift');
+}
+
+export function fromKey(e: { code: string; ctrlKey: boolean; altKey: boolean; shiftKey: boolean; metaKey: boolean }): string | null {
+  const m = /^(?:Key([A-Z])|Digit(\d)|(F(?:[1-9]|1\d|20)))$/.exec(e.code);
+  const key = m ? (m[1] ?? m[2] ?? m[3]) : NAMED[e.code] ?? PUNCTUATION[e.code];
+  if (!key) return null;
+  return [...[e.ctrlKey && 'Control', e.altKey && 'Alt', e.shiftKey && 'Shift', e.metaKey && 'Command'].filter(Boolean) as string[], key].join('+');
+}
+
+export const symbols = (accelerator: string) => canonical(accelerator).split('+').map(p => SYMBOLS[p] ?? p).join('');