mesurer-solid 0.1.0-beta.11

package/dist/core.js

@@ -0,0 +1,226 @@
+//#region ../mesurer-core/dist/domain.js
+var e = {
+	opacity: 1,
+	width: 1,
+	pattern: "solid",
+	dashLength: 6,
+	gap: 4
+}, t = {
+	opacity: 1,
+	edgeReveal: !1
+};
+//#endregion
+//#region ../mesurer-core/dist/events.js
+function n() {
+	let e = /* @__PURE__ */ new Map();
+	return {
+		on(t, n) {
+			let r = e.get(t) ?? /* @__PURE__ */ new Set();
+			return r.add(n), e.set(t, r), () => {
+				r.delete(n), r.size === 0 && e.delete(t);
+			};
+		},
+		async emit(t, n) {
+			for (let r of [...e.get(t) ?? []]) await r(n);
+		},
+		clear() {
+			e.clear();
+		}
+	};
+}
+({ ...e }), { ...t };
+//#endregion
+//#region ../mesurer-core/dist/plugins.js
+var r = 50;
+function i() {
+	let e = 1, t = 0, i = n(), a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map(), m = [], h = [], g = (e, t) => {
+		i.emit("changed", {
+			pluginId: e,
+			reason: t
+		});
+	}, _ = (t, n, r) => {
+		let i = e++;
+		t.set(i, {
+			...r,
+			pluginId: n,
+			registrationId: i
+		});
+		let a = !1;
+		return { dispose() {
+			a || (a = !0, t.delete(i), g(n, "registration"));
+		} };
+	}, v = (e, t) => {
+		let n = !1;
+		return { dispose() {
+			if (!n) {
+				n = !0;
+				try {
+					t();
+				} finally {
+					g(e, "registration");
+				}
+			}
+		} };
+	}, y = (e, t) => t === "all" || (t === "history" ? e.history === !0 : e.persist === !0), b = (e = "all") => {
+		let t = {};
+		for (let n of f.values()) !y(n, e) || !p.has(n.id) || (t[n.id] = p.get(n.id));
+		return t;
+	}, x = (e, t = "all") => {
+		let n = new Set([...f.values()].filter((e) => y(e, t)).map((e) => e.id));
+		for (let [t, r] of Object.entries(e)) n.has(t) && p.set(t, r);
+		g(void 0, "state");
+	}, S = (e, t) => {
+		let n = Object.keys(e), r = Object.keys(t);
+		return n.length === r.length && n.every((n) => Object.prototype.hasOwnProperty.call(t, n) && Object.is(e[n], t[n]));
+	}, C = () => {
+		m.length = 0, h.length = 0;
+	}, w = async (e, n, a) => {
+		let o = [...l.values()].reverse().find((t) => t.id === e);
+		if (!o) throw Error(`Unknown Mesurer command: ${e}`);
+		let s = t === 0, c = s ? b("history") : null;
+		t += 1;
+		try {
+			await o.handler(n, { source: a }), await i.emit("command", {
+				id: e,
+				args: n
+			});
+		} finally {
+			--t;
+		}
+		if (s && c) {
+			let e = b("history");
+			S(c, e) || (m.push(c), m.length > r && m.shift(), h.length = 0);
+		}
+	}, T = () => {
+		let e = m.pop();
+		return e ? (h.push(b("history")), h.length > r && h.shift(), x(e, "history"), g(void 0, "history"), !0) : !1;
+	}, E = () => {
+		let e = h.pop();
+		return e ? (m.push(b("history")), m.length > r && m.shift(), x(e, "history"), g(void 0, "history"), !0) : !1;
+	}, D = async (e, t) => {
+		for (let n of [...u.values()].filter((t) => t.name === e)) await n.handler(t);
+	}, O = (e) => [...d.values()].reverse().find((t) => t.id === e)?.value, k = {
+		get: (e) => p.get(e),
+		update(e, t) {
+			if (!p.has(e)) throw Error(`Unknown Mesurer state slice: ${e}`);
+			p.set(e, t(p.get(e))), g(void 0, "state");
+		},
+		serialize: b,
+		restore: x
+	}, A = (e, t) => {
+		let n = (e) => (t.push(e), e);
+		return {
+			state: {
+				register(t) {
+					let r = n(_(f, e, t));
+					return p.has(t.id) || p.set(t.id, t.initial), r;
+				},
+				get: k.get,
+				update: k.update
+			},
+			tool: { register: (t) => n(_(o, e, t)) },
+			settings: { register: (t) => n(_(s, e, t)) },
+			overlay: { register: (t) => n(_(c, e, t)) },
+			command: {
+				register: (t, r) => n(_(l, e, {
+					id: t,
+					handler: r
+				})),
+				execute: w
+			},
+			hook: {
+				on: (t, r) => n(_(u, e, {
+					name: t,
+					handler: r
+				})),
+				emit: D
+			},
+			service: {
+				provide: (t, r) => n(_(d, e, {
+					id: t,
+					value: r
+				})),
+				get: O
+			},
+			lifecycle: { onDispose: (t) => n(v(e, t)) }
+		};
+	}, j = () => {
+		let e = new Set([...f.values()].map((e) => e.id));
+		for (let t of [...p.keys()]) e.has(t) || p.delete(t);
+	}, M = (e) => {
+		let t = a.get(e);
+		if (!t) return !1;
+		for (let e of [...t.registrations].reverse()) e.dispose();
+		return a.delete(e), j(), C(), g(e, "remove"), !0;
+	}, N = async (e) => {
+		let t = a.has(e.id);
+		t && M(e.id);
+		let n = (e.requires ?? []).filter((e) => ![...a.values()].some(({ plugin: t }) => t.provides?.includes(e)));
+		if (n.length) throw Error(`Plugin ${e.id} requires missing capabilities: ${n.join(", ")}`);
+		let r = [];
+		try {
+			await e.setup(A(e.id, r)), a.set(e.id, {
+				plugin: e,
+				registrations: r
+			}), C(), g(e.id, t ? "replace" : "load");
+		} catch (e) {
+			for (let e of r.reverse()) e.dispose();
+			throw j(), e;
+		}
+	}, P = (e) => [...e].sort((e, t) => (e.order ?? 0) - (t.order ?? 0)), F = ({ pluginId: e, registrationId: t, ...n }) => n, I = {
+		load: N,
+		remove: M,
+		replace: N,
+		has: (e) => a.has(e),
+		plugin: (e) => a.get(e)?.plugin,
+		listPlugins: () => [...a.values()].map((e) => e.plugin),
+		tools: () => P(o.values()).map(F),
+		settings: () => P(s.values()).map(F),
+		overlays: () => P(c.values()).map(F),
+		state: k,
+		service: { get: O },
+		command: { execute: w },
+		hook: { emit: D },
+		undo: T,
+		redo: E,
+		canUndo: () => m.length > 0,
+		canRedo: () => h.length > 0,
+		subscribe: (e) => i.on("changed", e),
+		describe() {
+			return {
+				plugins: [...a.values()].map(({ plugin: e }) => ({
+					id: e.id,
+					version: e.version,
+					requires: e.requires ?? [],
+					provides: e.provides ?? []
+				})),
+				tools: I.tools().map(({ active: e, disabled: t, icon: n, ...r }) => r),
+				settings: I.settings(),
+				overlays: I.overlays(),
+				state: [...f.values()].map(({ id: e, history: t, persist: n }) => ({
+					id: e,
+					history: t ?? !1,
+					persist: n ?? !1
+				})),
+				commands: [...new Set([...l.values()].map((e) => e.id))],
+				hooks: [...new Set([...u.values()].map((e) => e.name))],
+				services: [...new Set([...d.values()].map((e) => e.id))]
+			};
+		},
+		dispose() {
+			for (let e of [...a.keys()].reverse()) M(e);
+			i.clear(), p.clear(), C();
+		}
+	};
+	return I;
+}
+//#endregion
+//#region src/core.ts
+var a = (e) => e, o = i;
+async function s(e = {}) {
+	let t = o();
+	for (let n of e.plugins ?? []) await t.load(n);
+	return t;
+}
+//#endregion
+export { o as createMesurerPluginHost, s as createMesurerRuntime, a as defineMesurerPlugin };

package/dist/host-layer.d.ts

@@ -0,0 +1,24 @@
+export type MesurerHostLayerMode = "top-layer" | "fixed";
+export type MesurerHostLayer = {
+    mode: MesurerHostLayerMode;
+    bringToFront(): void;
+    dispose(): void;
+};
+/**
+ * Mount Mesurer's outer host using browser top-layer primitives when available.
+ *
+ * Shadow DOM isolates Mesurer's internals from host CSS, but it does not by
+ * itself protect the shadow host from page stacking contexts, clipping, or
+ * author styles. A manual popover escapes ordinary document stacking and
+ * ancestor clipping. The fixed/max-z-index host is the compatibility fallback.
+ *
+ * The protected host itself is intentionally zero-sized with visible overflow.
+ * This lets Mesurer's fixed-position descendants receive pointer input without
+ * turning the protection layer into a viewport-sized click blocker for the app.
+ *
+ * Modal dialogs are special: the platform makes every node outside the active
+ * modal inert. When an observable modal opens, Mesurer temporarily reparents
+ * its host into that dialog so the toolbar stays interactive, then restores the
+ * original parent when the modal closes.
+ */
+export declare function mountMesurerHost(container: HTMLDivElement, target: HTMLElement | ShadowRoot, preferTopLayer?: boolean): MesurerHostLayer;

package/dist/index.d.ts

@@ -0,0 +1,210 @@
+import { type MesurerAgentHarness } from "./agent";
+import type { MesurerAnnotation, MesurerCapturePlanV1, MesurerContextRequest, MesurerContextV1, MesurerReviewV1 } from "./context";
+import type { MesurerPlugin, MesurerPluginDescription, MesurerPluginHost } from "./core";
+import { type MesurerHostLayerMode } from "./host-layer";
+export type ColorPickerFormat = "hex" | "rgb" | "hsl" | "oklch";
+export type MesurerBuiltinPluginId = "select" | "xray" | "color-picker" | "rulers" | "text-inspector" | "guides" | "distance" | "settings";
+export type LinePattern = "solid" | "dashed" | "dotted";
+export type LineStyle = {
+    opacity: number;
+    width: number;
+    pattern: LinePattern;
+    dashLength: number;
+    gap: number;
+};
+export type GuidePattern = LinePattern;
+export type GuideStyle = LineStyle;
+export type SelectionSpacingStyle = LineStyle & {
+    enabled: boolean;
+    color: string;
+};
+export type RulerSettings = {
+    opacity: number;
+    edgeReveal: boolean;
+};
+export type MesurerRect = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+export type MesurerMeasurement = {
+    id: string;
+    rect: MesurerRect;
+    normalizedRect: MesurerRect;
+    deltaX: number;
+    deltaY: number;
+    snapped?: boolean;
+};
+export type MesurerGuide = {
+    id: string;
+    orientation: "vertical" | "horizontal";
+    position: number;
+};
+export type MesurerDistance = {
+    id: string;
+    rectA: MesurerRect;
+    rectB: MesurerRect;
+    normalizedRectA: MesurerRect;
+    normalizedRectB: MesurerRect;
+    horizontal: {
+        x1: number;
+        x2: number;
+        y: number;
+        value: number;
+    } | null;
+    vertical: {
+        y1: number;
+        y2: number;
+        x: number;
+        value: number;
+    } | null;
+    connectors: Array<{
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    }>;
+};
+export type MesurerStoredSettings = {
+    highlightColor?: string;
+    guideColor?: string;
+    hoverHighlightEnabled?: boolean;
+    colorPickerFormats?: ColorPickerFormat[];
+    colorPickerClickFormat?: ColorPickerFormat;
+    snapEnabled?: boolean;
+    snapGuidesEnabled?: boolean;
+    selectNewGuideEnabled?: boolean;
+    multiMeasureEnabled?: boolean;
+    persistOnReload?: boolean;
+    guideStyle?: Partial<GuideStyle>;
+    selectionSpacingStyle?: Partial<SelectionSpacingStyle>;
+    rulerSettings?: Partial<RulerSettings>;
+};
+export type MesurerStoredWorkspace = {
+    enabled: boolean;
+    xrayVisible: boolean;
+    toolMode: "none" | "select" | "guides" | "text-inspector" | "xray" | "rulers";
+    rulersVisible: boolean;
+    guideOrientation: "vertical" | "horizontal";
+    guides: MesurerGuide[];
+    selectedGuideIds: string[];
+    measurements: MesurerMeasurement[];
+    activeMeasurement: MesurerMeasurement | null;
+    heldDistances: MesurerDistance[];
+};
+export type MesurerPersistenceSnapshot = {
+    settings: MesurerStoredSettings;
+    workspace: MesurerStoredWorkspace | null;
+};
+export type MesurerPersistence = {
+    load(): MesurerPersistenceSnapshot | null;
+    saveSettings(settings: MesurerStoredSettings): void;
+    saveWorkspace(workspace: MesurerStoredWorkspace): void;
+    clearWorkspace(): void;
+    clearSettings(): void;
+    subscribe?: (listener: (snapshot: MesurerPersistenceSnapshot | null, source?: {
+        settings?: boolean;
+        workspace?: boolean;
+    }) => void) => () => void;
+    setErrorHandler?: (handler: ((error: unknown) => void) | undefined) => void;
+};
+export type AgentBridgeOptions = {
+    globalName?: string;
+    root?: ParentNode;
+};
+export type MesurerOptions = {
+    highlightColor?: string;
+    guideColor?: string;
+    hoverHighlightEnabled?: boolean;
+    persistOnReload?: boolean;
+    persistKey?: string;
+    persistence?: MesurerPersistence;
+    onPersistenceError?: (error: unknown) => void;
+    colorPickerFormats?: ColorPickerFormat[];
+    colorPickerClickFormat?: ColorPickerFormat;
+    snapEnabled?: boolean;
+    snapGuidesEnabled?: boolean;
+    selectNewGuideEnabled?: boolean;
+    multiMeasureEnabled?: boolean;
+    guideStyle?: Partial<GuideStyle>;
+    selectionSpacingStyle?: Partial<SelectionSpacingStyle>;
+    rulerSettings?: Partial<RulerSettings>;
+    plugins?: MesurerPlugin[];
+    excludePlugins?: MesurerBuiltinPluginId[];
+    pluginHost?: MesurerPluginHost;
+    onPluginHost?: (host: MesurerPluginHost) => void;
+    onPluginsReady?: (host: MesurerPluginHost) => void;
+    onPluginError?: (error: unknown, pluginId: string) => void;
+};
+export type MountMeasurerOptions = MesurerOptions & {
+    target?: HTMLElement | ShadowRoot;
+    isolate?: boolean;
+    shadowMode?: ShadowRootMode;
+    topLayer?: boolean;
+    agent?: boolean | AgentBridgeOptions;
+};
+export type MesurerAgentCapabilities = {
+    protocol: "mesurer.agent/v1";
+    contextSchema: "mesurer.context/v1";
+    capabilities: {
+        context: boolean;
+        annotations: boolean;
+        review: boolean;
+        capturePlan: boolean;
+        screenshots: boolean;
+        send: boolean;
+    };
+};
+export type MesurerContextHarness = {
+    capabilities(): MesurerAgentCapabilities;
+    context(request?: MesurerContextRequest): Promise<MesurerContextV1>;
+    contextText(request?: MesurerContextRequest): Promise<string>;
+    annotations(): Promise<MesurerAnnotation[]>;
+    review(annotationId?: string): Promise<MesurerReviewV1 | MesurerReviewV1[]>;
+    capturePlan(request?: MesurerContextRequest): Promise<MesurerCapturePlanV1>;
+    prepareCapture(): Promise<void>;
+    finishCapture(): Promise<void>;
+    sendContext(request?: MesurerContextRequest): Promise<void>;
+};
+export type MesurerBrowserAgent = MesurerAgentHarness & MesurerContextHarness;
+export type MountedMeasurer = {
+    element: HTMLDivElement;
+    root: HTMLDivElement | ShadowRoot;
+    readonly hostLayer: MesurerHostLayerMode;
+    readonly pluginHost: MesurerPluginHost | undefined;
+    readonly ready: Promise<void>;
+    readonly agent: MesurerBrowserAgent;
+    context(request?: MesurerContextRequest): Promise<MesurerContextV1>;
+    contextText(request?: MesurerContextRequest): Promise<string>;
+    copyContext(request?: MesurerContextRequest): Promise<void>;
+    annotations(): Promise<MesurerAnnotation[]>;
+    review(annotationId?: string): Promise<MesurerReviewV1 | MesurerReviewV1[]>;
+    capturePlan(request?: MesurerContextRequest): Promise<MesurerCapturePlanV1>;
+    prepareCapture(): Promise<void>;
+    finishCapture(): Promise<void>;
+    sendContext(request?: MesurerContextRequest): Promise<void>;
+    bringToFront(): void;
+    describe(): MesurerPluginDescription | undefined;
+    dispose(): void;
+};
+export declare function mountMeasurer(options?: MountMeasurerOptions): MountedMeasurer;
+export { createMesurerAgentHarness } from "./agent";
+export type { AgentDistance, AgentEdges, AgentElementInspection, AgentFeedbackSnapshot, AgentRect, AgentViewportSnapshot, CreateMesurerAgentHarnessOptions, MesurerAgentHarness, } from "./agent";
+export { captureMesurerContext, copyTextToClipboard, createMesurerCapturePlan, formatMesurerContext, reviewMesurerAnnotation, toAcpContentBlocks, } from "./context";
+export type { AcpImageContentBlock, AcpTextContentBlock, MesurerAcpContentBlock, MesurerAnnotation, MesurerAnnotationBaseline, MesurerAnnotationTarget, MesurerCapturePlanV1, MesurerContextDelivery, MesurerContextDistance, MesurerContextEdges, MesurerContextGuide, MesurerContextMeasurement, MesurerContextRect, MesurerContextRequest, MesurerContextSender, MesurerContextTarget, MesurerContextV1, MesurerElementFingerprint, MesurerElementInspection, MesurerEvidenceImage, MesurerEvidenceProvider, MesurerReviewChange, MesurerReviewMetricChange, MesurerReviewPresenceChange, MesurerReviewV1, } from "./context";
+export { contextPlugin, MESURER_CONTEXT_PLUGIN_ID, MESURER_CONTEXT_SERVICE_ID, } from "./context-plugin";
+export type { MesurerContextPluginOptions, MesurerContextService, } from "./context-plugin";
+export { createMesurerPluginHost, createMesurerRuntime, defineMesurerPlugin } from "./core";
+export type { CommandHandler as MesurerCommandHandler, MesurerPlugin, MesurerPluginContext, MesurerPluginDescription, MesurerPluginHost, OverlayContribution, Registration as MesurerRegistration, SettingsContribution, StateSliceDefinition, ToolContribution, } from "./core";
+export type { MesurerHostLayerMode } from "./host-layer";
+export declare const selectPlugin: () => MesurerPlugin;
+export declare const xrayPlugin: () => MesurerPlugin;
+export declare const colorPickerPlugin: () => MesurerPlugin;
+export declare const rulersPlugin: () => MesurerPlugin;
+export declare const textInspectorPlugin: () => MesurerPlugin;
+export declare const guidesPlugin: () => MesurerPlugin;
+export declare const distancePlugin: () => MesurerPlugin;
+export declare const settingsPlugin: () => MesurerPlugin;
+export declare const defaultMesurerPlugins: () => MesurerPlugin[];
+export declare const composeMesurerPlugins: (plugins?: MesurerPlugin[], exclude?: MesurerBuiltinPluginId[]) => MesurerPlugin[];