@pstdio/canvas 0.0.0-stage → 0.45.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,183 @@
1
+ import { Component, type ReactNode, useLayoutEffect } from "react";
2
+ import { createRoot } from "react-dom/client";
3
+ import {
4
+ type CanvasMeta,
5
+ type CanvasProject,
6
+ CanvasThemeContext,
7
+ type CanvasVariant,
8
+ composePreview,
9
+ } from "../compose";
10
+ import { installFrameNavigation } from "./navigation";
11
+ import { type FrameItem, type FrameMessage, type FrameRequest, type FrameTheme, frameProtocol } from "./protocol";
12
+
13
+ /** How the generated frame entry loads one canvas file and its nearest `.canvas/preview.tsx`. */
14
+ export interface FrameSource {
15
+ load: () => Promise<Record<string, unknown>>;
16
+ preview?: () => Promise<{ default?: unknown }>;
17
+ }
18
+
19
+ type LoadedFrame = Awaited<ReturnType<typeof composePreview>> & { timings: Record<string, number> };
20
+
21
+ const inspect = (value: unknown) => {
22
+ const seen = new WeakSet<object>();
23
+ return JSON.stringify(
24
+ value,
25
+ (_key, item) => {
26
+ if (typeof item === "function") return `[callback ${item.name || "local"}]`;
27
+ if (typeof item === "bigint" || typeof item === "symbol") return String(item);
28
+ if (item && typeof item === "object") {
29
+ if (seen.has(item)) return "[shared reference]";
30
+ seen.add(item);
31
+ }
32
+ return item;
33
+ },
34
+ 2,
35
+ );
36
+ };
37
+
38
+ /** Renders one canvas frame inside a UI Canvas iframe. The generated build entry calls this. */
39
+ export const mountFrameRuntime = (sources: Record<string, FrameSource>) => {
40
+ const booted = performance.now();
41
+ let nonce = "";
42
+ const send = (message: Omit<FrameMessage, "protocol" | "nonce">) =>
43
+ window.parent.postMessage({ protocol: frameProtocol, nonce, ...message }, "*");
44
+
45
+ class Boundary extends Component<{ children: ReactNode }, { error?: string }> {
46
+ state: { error?: string } = {};
47
+ static getDerivedStateFromError(error: Error) {
48
+ return { error: error.message };
49
+ }
50
+ componentDidCatch(error: Error) {
51
+ send({ type: "error", message: error.message });
52
+ }
53
+ render() {
54
+ return this.state.error ? <div role="alert">{this.state.error}</div> : this.props.children;
55
+ }
56
+ }
57
+
58
+ const Ready = (props: { loaded: LoadedFrame; minimumHeight: number }) => {
59
+ const { loaded, minimumHeight } = props;
60
+ useLayoutEffect(() => {
61
+ let second = 0;
62
+ // Offscreen iframe animation frames can be suspended; readiness must not wait for paint.
63
+ send({
64
+ type: "loaded",
65
+ timings: {
66
+ ...loaded.timings,
67
+ bootstrapMs: booted - (performance.getEntriesByName("canvas:bootstrap-received")[0]?.startTime ?? 0),
68
+ committedMs: performance.now(),
69
+ },
70
+ information: { args: inspect(loaded.args), description: loaded.description },
71
+ });
72
+ const first = requestAnimationFrame(() => {
73
+ second = requestAnimationFrame(() => send({ type: "painted", timings: { firstPaintMs: performance.now() } }));
74
+ });
75
+ return () => {
76
+ cancelAnimationFrame(first);
77
+ cancelAnimationFrame(second);
78
+ };
79
+ }, [loaded]);
80
+ const Frame = loaded.Component;
81
+ return (
82
+ <div
83
+ data-preview-content
84
+ style={{ display: "grid", minHeight: minimumHeight ? `${minimumHeight}px` : undefined }}
85
+ >
86
+ <Frame />
87
+ </div>
88
+ );
89
+ };
90
+
91
+ const load = async (item: FrameItem): Promise<LoadedFrame> => {
92
+ const preview = item.preview;
93
+ if (!preview) throw new Error("This frame has no preview");
94
+ const source = sources[preview.source];
95
+ if (!source) throw new Error(`Missing preview source: ${preview.source}`);
96
+ const started = performance.now();
97
+ const [module, project] = await Promise.all([source.load(), source.preview?.()]);
98
+ const frame = module[preview.exportName];
99
+ if (frame === undefined) throw new Error(`Missing preview: ${preview.source}#${preview.exportName}`);
100
+ send({ type: "imports-ready" });
101
+ const importedAt = performance.now();
102
+ const composed = await composePreview(
103
+ frame as CanvasVariant,
104
+ (module.default ?? {}) as CanvasMeta,
105
+ (project?.default ?? {}) as CanvasProject,
106
+ );
107
+ return { ...composed, timings: { importMs: importedAt - started, setupMs: performance.now() - importedAt } };
108
+ };
109
+
110
+ const root = document.getElementById("root")!;
111
+ const reactRoot = createRoot(root);
112
+ let theme: FrameTheme = { id: "light", mode: "light" };
113
+ let item: FrameItem | undefined;
114
+ let loaded: LoadedFrame | undefined;
115
+ let active = true;
116
+ const render = () => {
117
+ if (!active || !loaded || !item) return;
118
+ const minimumHeight = loaded.fullscreen ? (item.preview?.viewportHeight ?? 960) : 0;
119
+ reactRoot.render(
120
+ <CanvasThemeContext.Provider value={theme.mode}>
121
+ <Boundary>
122
+ <Ready loaded={loaded} minimumHeight={minimumHeight} />
123
+ </Boundary>
124
+ </CanvasThemeContext.Provider>,
125
+ );
126
+ };
127
+ const receive = (event: MessageEvent<FrameRequest>) => {
128
+ const message = event.data;
129
+ if (event.source !== window.parent || message?.protocol !== frameProtocol) return;
130
+ if (nonce && message.nonce !== nonce) return;
131
+ nonce = message.nonce;
132
+ if (message.theme) theme = message.theme;
133
+ if (message.type === "theme") render();
134
+ if (message.type !== "render" || !message.item || item) return;
135
+ item = message.item;
136
+ void load(message.item)
137
+ .then((result) => {
138
+ if (!active) return result.dispose();
139
+ loaded = result;
140
+ render();
141
+ })
142
+ .catch((error) => {
143
+ if (!active) return;
144
+ reactRoot.render(<div role="alert">{String(error)}</div>);
145
+ send({ type: "error", message: String(error) });
146
+ });
147
+ };
148
+ window.addEventListener("message", receive);
149
+ send({ type: "boot" });
150
+
151
+ let scheduled = 0;
152
+ let previous = 0;
153
+ const measure = () => {
154
+ cancelAnimationFrame(scheduled);
155
+ scheduled = requestAnimationFrame(() => {
156
+ const height = Math.ceil(Math.max(root.offsetHeight, root.scrollHeight, 1));
157
+ if (height === previous) return;
158
+ previous = height;
159
+ send({ type: "height", height });
160
+ });
161
+ };
162
+ const resizeObserver = new ResizeObserver(measure);
163
+ resizeObserver.observe(root);
164
+ const mutationObserver = new MutationObserver(measure);
165
+ mutationObserver.observe(document.body, { subtree: true, childList: true, attributes: true });
166
+ document.fonts.addEventListener("loadingdone", measure);
167
+ void document.fonts.ready.then(measure);
168
+ installFrameNavigation(send);
169
+ window.addEventListener(
170
+ "pagehide",
171
+ () => {
172
+ active = false;
173
+ window.removeEventListener("message", receive);
174
+ loaded?.dispose();
175
+ cancelAnimationFrame(scheduled);
176
+ resizeObserver.disconnect();
177
+ mutationObserver.disconnect();
178
+ document.fonts.removeEventListener("loadingdone", measure);
179
+ reactRoot.unmount();
180
+ },
181
+ { once: true },
182
+ );
183
+ };
@@ -0,0 +1,135 @@
1
+ import type { FrameMessage } from "./protocol";
2
+
3
+ export const installFrameNavigation = (send: (message: Omit<FrameMessage, "protocol" | "nonce">) => void) => {
4
+ const scrolls = (target: EventTarget | null, x: number, y: number) => {
5
+ let node = target instanceof Element ? target : null;
6
+ while (node && node !== document.body) {
7
+ const style = getComputedStyle(node);
8
+ if (
9
+ /auto|scroll/.test(style.overflowY) &&
10
+ ((y < 0 && node.scrollTop > 0) || (y > 0 && node.scrollTop + node.clientHeight < node.scrollHeight - 1))
11
+ )
12
+ return true;
13
+ if (
14
+ /auto|scroll/.test(style.overflowX) &&
15
+ ((x < 0 && node.scrollLeft > 0) || (x > 0 && node.scrollLeft + node.clientWidth < node.scrollWidth - 1))
16
+ )
17
+ return true;
18
+ node = node.parentElement;
19
+ }
20
+ return false;
21
+ };
22
+ document.addEventListener(
23
+ "wheel",
24
+ (event) => {
25
+ if (event.defaultPrevented) return;
26
+ const unit = [1, 16, window.innerHeight][event.deltaMode] ?? 1;
27
+ const zoom = event.ctrlKey || event.metaKey;
28
+ if (!zoom && scrolls(event.target, event.deltaX * unit, event.deltaY * unit)) return;
29
+ event.preventDefault();
30
+ send({
31
+ type: "wheel",
32
+ x: event.clientX,
33
+ y: event.clientY,
34
+ deltaX: event.deltaX * unit,
35
+ deltaY: event.deltaY * unit,
36
+ zoom,
37
+ });
38
+ },
39
+ { passive: false },
40
+ );
41
+ let interacted = false;
42
+ document.addEventListener(
43
+ "pointerdown",
44
+ () => {
45
+ interacted = true;
46
+ },
47
+ true,
48
+ );
49
+ document.addEventListener(
50
+ "keydown",
51
+ () => {
52
+ interacted = true;
53
+ },
54
+ true,
55
+ );
56
+ let space = false;
57
+ let dragged = false;
58
+ let pan: { id: number; x: number; y: number } | undefined;
59
+ const control = (target: EventTarget | null) =>
60
+ target instanceof Element &&
61
+ target.closest('input,textarea,button,select,[contenteditable],a[href],[role="combobox"]');
62
+ document.addEventListener("keydown", (event) => {
63
+ if (event.code === "Space" && !control(event.target)) {
64
+ space = true;
65
+ event.preventDefault();
66
+ }
67
+ });
68
+ document.addEventListener("keyup", (event) => {
69
+ if (event.code === "Space") space = false;
70
+ });
71
+ window.addEventListener("blur", () => {
72
+ space = false;
73
+ pan = undefined;
74
+ });
75
+ document.addEventListener(
76
+ "pointerdown",
77
+ (event) => {
78
+ if (event.button !== 1 && !(space && !control(document.activeElement))) return;
79
+ event.preventDefault();
80
+ event.stopPropagation();
81
+ dragged = false;
82
+ pan = { id: event.pointerId, x: event.screenX, y: event.screenY };
83
+ (event.target as Element).setPointerCapture(event.pointerId);
84
+ },
85
+ true,
86
+ );
87
+ document.addEventListener(
88
+ "pointermove",
89
+ (event) => {
90
+ if (pan?.id !== event.pointerId) return;
91
+ event.preventDefault();
92
+ event.stopPropagation();
93
+ dragged ||= Math.abs(event.screenX - pan.x) + Math.abs(event.screenY - pan.y) > 3;
94
+ send({ type: "pan", deltaX: event.screenX - pan.x, deltaY: event.screenY - pan.y });
95
+ pan = { ...pan, x: event.screenX, y: event.screenY };
96
+ },
97
+ true,
98
+ );
99
+ const end = () => {
100
+ pan = undefined;
101
+ };
102
+ document.addEventListener("pointerup", end, true);
103
+ document.addEventListener(
104
+ "pointercancel",
105
+ () => {
106
+ end();
107
+ dragged = false;
108
+ },
109
+ true,
110
+ );
111
+ const suppressDragClick = (event: MouseEvent) => {
112
+ if (!dragged) return;
113
+ dragged = false;
114
+ event.preventDefault();
115
+ event.stopPropagation();
116
+ };
117
+ document.addEventListener("click", suppressDragClick, true);
118
+ document.addEventListener("auxclick", suppressDragClick, true);
119
+ document.addEventListener("focusin", (event) => {
120
+ const target = event.target;
121
+ if (!interacted || !(target instanceof HTMLElement)) return;
122
+ requestAnimationFrame(() => {
123
+ if (!target.isConnected || document.activeElement !== target) return;
124
+ const rect = target.getBoundingClientRect();
125
+ send({ type: "focus", x: rect.left, y: rect.top, width: rect.width, height: rect.height });
126
+ });
127
+ });
128
+ document.addEventListener("click", (event) => {
129
+ const link = event.target instanceof Element ? event.target.closest("a[href]") : null;
130
+ if (!link) return;
131
+ const href = link.getAttribute("href") ?? "";
132
+ if (href.startsWith("#canvas-item=")) send({ type: "reveal", id: decodeURIComponent(href.slice(13)) });
133
+ if (!href.startsWith("#") || href.startsWith("#canvas-item=")) event.preventDefault();
134
+ });
135
+ };
@@ -0,0 +1,54 @@
1
+ // The messages between a UI Canvas frame and its host. They match the protocol the UI Canvas
2
+ // extension speaks; the extension reads these types from this package once it adopts it.
3
+ export const frameProtocol = "pstdio.canvas.preview";
4
+
5
+ export interface FrameTheme {
6
+ id: string;
7
+ mode: "light" | "dark";
8
+ }
9
+
10
+ export interface FrameItem {
11
+ preview?: { source: string; exportName: string; viewportHeight?: number };
12
+ }
13
+
14
+ export interface FrameRequest {
15
+ protocol: typeof frameProtocol;
16
+ nonce: string;
17
+ type: "render" | "theme" | "bootstrap" | "assets";
18
+ requestId?: string;
19
+ error?: string;
20
+ item?: FrameItem;
21
+ theme?: FrameTheme;
22
+ }
23
+
24
+ export interface FrameMessage {
25
+ protocol: typeof frameProtocol;
26
+ type:
27
+ | "bootstrap"
28
+ | "boot"
29
+ | "height"
30
+ | "loaded"
31
+ | "error"
32
+ | "wheel"
33
+ | "pan"
34
+ | "reveal"
35
+ | "focus"
36
+ | "assets"
37
+ | "imports-ready"
38
+ | "painted";
39
+ requestId?: string;
40
+ source?: string;
41
+ timings?: Record<string, number>;
42
+ nonce?: string;
43
+ height?: number;
44
+ width?: number;
45
+ message?: string;
46
+ id?: string;
47
+ x?: number;
48
+ y?: number;
49
+ deltaX?: number;
50
+ deltaY?: number;
51
+ deltaMode?: number;
52
+ zoom?: boolean;
53
+ information?: { args?: string; description?: string };
54
+ }