Files
persionalBrand/apps/admin/src/features/brand/ComponentTemplatePreview.tsx
T

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