226 lines
8.6 KiB
TypeScript
226 lines
8.6 KiB
TypeScript
import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
|
|
import type { RuntimeWorkspace } from "@personal-brand/api-client";
|
|
import { Alert } from "antd";
|
|
import { resolveTemplateRenderer } from "./component-renderers.jsx";
|
|
import type { PreviewSelection, PreviewTarget } from "./preview-selection.js";
|
|
import "./ComponentTemplatePreview.css";
|
|
|
|
type PreviewProps = {
|
|
workspace: RuntimeWorkspace;
|
|
page: string;
|
|
offeringId?: string;
|
|
selection?: PreviewSelection;
|
|
targets: PreviewTarget[];
|
|
onTargetSelected: (selection?: PreviewSelection) => void;
|
|
};
|
|
|
|
type Outline = { top: number; left: number; width: number; height: number; label: string };
|
|
|
|
export function ComponentTemplatePreview({
|
|
workspace,
|
|
page,
|
|
offeringId,
|
|
selection,
|
|
targets,
|
|
onTargetSelected,
|
|
}: PreviewProps) {
|
|
const Renderer = resolveTemplateRenderer(workspace);
|
|
const root = useRef<HTMLDivElement>(null);
|
|
const [mode, setMode] = useState<"edit" | "browse">("edit");
|
|
const [hovered, setHovered] = useState<HTMLElement | null>(null);
|
|
const [hoverOutline, setHoverOutline] = useState<Outline | null>(null);
|
|
const [selectedOutline, setSelectedOutline] = useState<Outline | null>(null);
|
|
const [compositeOutlines, setCompositeOutlines] = useState<Array<Outline & { key: string }>>([]);
|
|
const targetFor = useCallback(
|
|
(element: Element | null): HTMLElement | null => {
|
|
let candidate = element?.closest<HTMLElement>("[data-editor-target]");
|
|
let deepest: HTMLElement | null = null;
|
|
let composite: HTMLElement | null = null;
|
|
while (candidate && root.current?.contains(candidate)) {
|
|
const target = targets.find((item) => item.key === candidate?.dataset.editorTarget);
|
|
if (target && !deepest) deepest = candidate;
|
|
if (target?.composite) composite = candidate;
|
|
candidate = candidate.parentElement?.closest<HTMLElement>("[data-editor-target]") ?? null;
|
|
}
|
|
return deepest ?? composite;
|
|
},
|
|
[targets],
|
|
);
|
|
const selectedElement = useCallback(() => {
|
|
if (!selection) return null;
|
|
return (
|
|
Array.from(root.current?.querySelectorAll<HTMLElement>("[data-editor-target]") ?? []).find(
|
|
(element) =>
|
|
element.dataset.editorTarget === selection.targetKey &&
|
|
(element.dataset.editorRecordId || undefined) === selection.recordId,
|
|
) ?? null
|
|
);
|
|
}, [selection]);
|
|
const measure = useCallback(
|
|
(element: HTMLElement | null): Outline | null => {
|
|
const viewport = root.current;
|
|
if (!element || !viewport || !viewport.contains(element)) return null;
|
|
const box = element.getBoundingClientRect();
|
|
const parent = viewport.getBoundingClientRect();
|
|
const target = targets.find((item) => item.key === element.dataset.editorTarget);
|
|
if (!target || !box.width || !box.height) return null;
|
|
return {
|
|
top: box.top - parent.top + viewport.scrollTop,
|
|
left: box.left - parent.left + viewport.scrollLeft,
|
|
width: box.width,
|
|
height: box.height,
|
|
label: target.label,
|
|
};
|
|
},
|
|
[targets],
|
|
);
|
|
useLayoutEffect(() => {
|
|
const viewport = root.current;
|
|
if (!viewport) return;
|
|
let frame = 0;
|
|
const update = () => {
|
|
cancelAnimationFrame(frame);
|
|
frame = requestAnimationFrame(() => {
|
|
setSelectedOutline(measure(selectedElement()));
|
|
setHoverOutline(measure(hovered));
|
|
setCompositeOutlines(
|
|
targets
|
|
.filter((target) => target.composite)
|
|
.flatMap((target) => {
|
|
const element = viewport.querySelector<HTMLElement>(
|
|
`[data-editor-target="${CSS.escape(target.key)}"]`,
|
|
);
|
|
const outline = measure(element);
|
|
return outline ? [{ ...outline, key: target.key }] : [];
|
|
}),
|
|
);
|
|
});
|
|
};
|
|
update();
|
|
const resize = new ResizeObserver(update);
|
|
resize.observe(viewport);
|
|
viewport
|
|
.querySelectorAll<HTMLElement>("[data-editor-target]")
|
|
.forEach((node) => resize.observe(node));
|
|
window.addEventListener("resize", update);
|
|
viewport.addEventListener("scroll", update);
|
|
viewport.addEventListener("load", update, true);
|
|
return () => {
|
|
cancelAnimationFrame(frame);
|
|
resize.disconnect();
|
|
window.removeEventListener("resize", update);
|
|
viewport.removeEventListener("scroll", update);
|
|
viewport.removeEventListener("load", update, true);
|
|
};
|
|
}, [hovered, measure, selectedElement, workspace, page]);
|
|
useEffect(() => {
|
|
selectedElement()?.scrollIntoView({ block: "nearest", behavior: "smooth" });
|
|
}, [selectedElement]);
|
|
useEffect(() => {
|
|
const clear = (event: KeyboardEvent) => {
|
|
if (event.key === "Escape") onTargetSelected(undefined);
|
|
};
|
|
window.addEventListener("keydown", clear);
|
|
return () => window.removeEventListener("keydown", clear);
|
|
}, [onTargetSelected]);
|
|
if (!Renderer)
|
|
return <Alert type="warning" showIcon message="此模板尚无组件预览,请使用页面预览" />;
|
|
return (
|
|
<div className="component-template-preview-shell">
|
|
<div
|
|
className="component-template-preview__tools"
|
|
aria-label="预览操作模式"
|
|
hidden={!targets.length}
|
|
>
|
|
<button type="button" aria-pressed={mode === "edit"} onClick={() => setMode("edit")}>
|
|
点选编辑
|
|
</button>
|
|
<button type="button" aria-pressed={mode === "browse"} onClick={() => setMode("browse")}>
|
|
浏览页面
|
|
</button>
|
|
</div>
|
|
<div
|
|
ref={root}
|
|
className="component-template-preview"
|
|
data-active-target={selection?.targetKey}
|
|
data-active-record-id={selection?.recordId}
|
|
data-editor-mode={mode}
|
|
onPointerMoveCapture={(event) => {
|
|
if (mode !== "edit" || !targets.length) return;
|
|
const next = targetFor(event.target instanceof Element ? event.target : null);
|
|
if (next !== hovered) setHovered(next);
|
|
}}
|
|
onPointerLeave={() => setHovered(null)}
|
|
onClickCapture={(event) => {
|
|
if (mode !== "edit" || !targets.length) return;
|
|
const canvas = root.current?.querySelector(".component-template-preview__canvas");
|
|
if (!event.target || !(event.target instanceof Node) || !canvas?.contains(event.target))
|
|
return;
|
|
const pointTarget = document.elementFromPoint(event.clientX, event.clientY);
|
|
const element = targetFor(
|
|
pointTarget && canvas.contains(pointTarget) ? pointTarget : null,
|
|
);
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
onTargetSelected(
|
|
element
|
|
? {
|
|
targetKey: element.dataset.editorTarget!,
|
|
...(element.dataset.editorRecordId
|
|
? { recordId: element.dataset.editorRecordId }
|
|
: {}),
|
|
}
|
|
: undefined,
|
|
);
|
|
}}
|
|
>
|
|
<div className="component-template-preview__canvas">
|
|
<Renderer workspace={workspace} page={page} {...(offeringId ? { offeringId } : {})} />
|
|
</div>
|
|
{mode === "edit"
|
|
? compositeOutlines.map((outline) => (
|
|
<button
|
|
key={outline.key}
|
|
type="button"
|
|
className="component-template-preview__composite-select"
|
|
style={{ top: outline.top + 4, left: outline.left + 4 }}
|
|
aria-label={`选择${targets.find((target) => target.key === outline.key)?.label ?? outline.label}`}
|
|
onClick={() => onTargetSelected({ targetKey: outline.key })}
|
|
>
|
|
选择{targets.find((target) => target.key === outline.key)?.label ?? outline.label}
|
|
</button>
|
|
))
|
|
: null}
|
|
{mode === "edit" && hoverOutline ? (
|
|
<div
|
|
className="component-template-preview__outline is-hovered"
|
|
style={{
|
|
top: hoverOutline.top,
|
|
left: hoverOutline.left,
|
|
width: hoverOutline.width,
|
|
height: hoverOutline.height,
|
|
}}
|
|
aria-hidden="true"
|
|
/>
|
|
) : null}
|
|
{mode === "edit" && selectedOutline ? (
|
|
<div
|
|
className="component-template-preview__outline is-selected"
|
|
style={{
|
|
top: selectedOutline.top,
|
|
left: selectedOutline.left,
|
|
width: selectedOutline.width,
|
|
height: selectedOutline.height,
|
|
}}
|
|
data-selected-target={selection?.targetKey}
|
|
data-selected-record-id={selection?.recordId}
|
|
>
|
|
<span>{selectedOutline.label}</span>
|
|
</div>
|
|
) : null}
|
|
</div>
|
|
</div>
|
|
);
|
|
}
|
|
// @ts-nocheck
|