@ecomcx/ecomweb-editor 1.18.0 → 1.20.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.
Files changed (87) hide show
  1. package/package.json +25 -7
  2. package/src/index.ts +26 -25
  3. package/src/{ask.tsx → legacy/ask.tsx} +2 -2
  4. package/src/{blockMeta.ts → legacy/block-meta.ts} +1 -1
  5. package/src/{blocks.tsx → legacy/blocks.tsx} +8 -32
  6. package/src/{content.ts → legacy/content.ts} +1 -1
  7. package/src/{handle.tsx → legacy/drag-handle.tsx} +3 -3
  8. package/src/{dynamic.tsx → legacy/dynamic.tsx} +7 -3
  9. package/src/{Editor.tsx → legacy/editor.tsx} +9 -9
  10. package/src/{extensions.ts → legacy/extensions.ts} +1 -1
  11. package/src/legacy/insert-pattern.ts +13 -0
  12. package/src/{inserter.tsx → legacy/inserter.tsx} +6 -5
  13. package/src/{inspector.tsx → legacy/inspector.tsx} +7 -7
  14. package/src/{layoutUi.tsx → legacy/layout-ui.tsx} +6 -5
  15. package/src/{layout.tsx → legacy/layout.tsx} +2 -2
  16. package/src/{media.ts → legacy/media.ts} +1 -1
  17. package/src/{nodes.tsx → legacy/nodes.tsx} +2 -2
  18. package/src/{outline.tsx → legacy/outline.tsx} +4 -4
  19. package/src/legacy/panels.ts +22 -0
  20. package/src/{rank.ts → legacy/rank.ts} +2 -2
  21. package/src/{registry.ts → legacy/registry.ts} +1 -1
  22. package/src/{handles.tsx → legacy/resize-handles.tsx} +1 -1
  23. package/src/{styleattr.ts → legacy/style-attr.ts} +15 -1
  24. package/src/{synced.tsx → legacy/synced.tsx} +2 -2
  25. package/src/{toolbar.tsx → legacy/toolbar.tsx} +7 -7
  26. package/src/{unknown.tsx → legacy/unknown.tsx} +1 -1
  27. package/src/shared/block-defs.ts +38 -0
  28. package/src/shared/color-swatch.tsx +19 -0
  29. package/src/{panels.ts → shared/panel-store.ts} +4 -21
  30. package/src/{patterns.ts → shared/patterns.ts} +0 -12
  31. package/src/{stylepanel.tsx → shared/style-panel.tsx} +2 -2
  32. package/src/{types.ts → shared/types.ts} +2 -0
  33. package/src/v2/blocks/compat.tsx +51 -0
  34. package/src/v2/blocks/index.ts +42 -0
  35. package/src/v2/blocks/layout.tsx +281 -0
  36. package/src/v2/blocks/media-actions.tsx +76 -0
  37. package/src/v2/blocks/media.tsx +234 -0
  38. package/src/v2/blocks/resize.tsx +111 -0
  39. package/src/v2/blocks/text.tsx +150 -0
  40. package/src/v2/blocks/theme.tsx +293 -0
  41. package/src/v2/blocks/tools.tsx +72 -0
  42. package/src/v2/canvas/block-list.tsx +216 -0
  43. package/src/v2/canvas/canvas-css.ts +131 -0
  44. package/src/v2/canvas/canvas.tsx +379 -0
  45. package/src/v2/canvas/dnd.ts +192 -0
  46. package/src/v2/context.tsx +146 -0
  47. package/src/v2/core/bindings.ts +64 -0
  48. package/src/v2/core/clipboard.ts +238 -0
  49. package/src/v2/core/host.ts +80 -0
  50. package/src/v2/core/model.ts +157 -0
  51. package/src/v2/core/ops.ts +151 -0
  52. package/src/v2/core/patterns.ts +10 -0
  53. package/src/v2/core/registry.ts +135 -0
  54. package/src/v2/core/store.ts +804 -0
  55. package/src/v2/core/structure.ts +106 -0
  56. package/src/v2/core/tables.ts +194 -0
  57. package/src/v2/editor.css +324 -0
  58. package/src/v2/editor.tsx +288 -0
  59. package/src/v2/index.ts +28 -0
  60. package/src/v2/labels.ts +349 -0
  61. package/src/v2/prefs.ts +69 -0
  62. package/src/v2/text/paste.ts +75 -0
  63. package/src/v2/text/rich-schema.ts +96 -0
  64. package/src/v2/text/rich-text.tsx +512 -0
  65. package/src/v2/ui/attr-form.tsx +182 -0
  66. package/src/v2/ui/attr-hints.ts +129 -0
  67. package/src/v2/ui/bindings.tsx +91 -0
  68. package/src/v2/ui/block-descriptions.ts +34 -0
  69. package/src/v2/ui/color-field.tsx +17 -0
  70. package/src/v2/ui/doc-title.tsx +45 -0
  71. package/src/v2/ui/inserter.tsx +300 -0
  72. package/src/v2/ui/inspector.tsx +85 -0
  73. package/src/v2/ui/layout-panel.tsx +159 -0
  74. package/src/v2/ui/list-view.tsx +65 -0
  75. package/src/v2/ui/options.tsx +242 -0
  76. package/src/v2/ui/style-controls.tsx +57 -0
  77. package/src/v2/ui/style-tab.tsx +158 -0
  78. package/src/v2/ui/toolbar.tsx +402 -0
  79. package/src/v2/ui/unit-controls.tsx +99 -0
  80. /package/src/{basic.tsx → legacy/basic.tsx} +0 -0
  81. /package/src/{blockops.ts → legacy/block-ops.ts} +0 -0
  82. /package/src/{boundary.tsx → legacy/boundary.tsx} +0 -0
  83. /package/src/{editor.css → legacy/editor.css} +0 -0
  84. /package/src/{insert.ts → legacy/insert.ts} +0 -0
  85. /package/src/{labels.ts → shared/labels.ts} +0 -0
  86. /package/src/{paste.ts → shared/paste.ts} +0 -0
  87. /package/src/{util.ts → shared/util.ts} +0 -0
@@ -0,0 +1,192 @@
1
+ import type { PointerEvent as ReactPointerEvent } from "react";
2
+ import type { EditorContextValue, DropTarget } from "../context";
3
+ import type { InsertOption } from "../ui/inserter";
4
+ import type { BNode } from "../core/model";
5
+ import { canContain } from "../core/structure";
6
+ import { sectionOf } from "./block-list";
7
+
8
+ /**
9
+ * Kéo thả bằng pointer (không dùng HTML5 drag): kéo khối (tay nắm, cây khối) hoặc khối mới (thư viện) vào khung soạn.
10
+ * Vị trí thả: khối dưới con trỏ → trước/sau theo nửa trên/dưới (nửa trái/phải nếu khối cha xếp ngang), khối chứa trống → vào trong.
11
+ * Chỗ không đặt được (cột ngoài bộ cột…) thì leo lên khối cha.
12
+ */
13
+ const THRESHOLD = 5;
14
+
15
+ export function startDrag(ctx: EditorContextValue, e: ReactPointerEvent, ids: string[]) {
16
+ if (e.button !== 0 || !ids.length || !ids.every((id) => ctx.store.canMove(id))) return;
17
+ const types = ids.map((id) => ctx.store.block(id)?.type).filter(Boolean) as string[];
18
+ begin(ctx, e, { ids, types });
19
+ }
20
+
21
+ export function startDragNew(ctx: EditorContextValue, e: ReactPointerEvent, option: InsertOption) {
22
+ if (e.button !== 0) return;
23
+ begin(ctx, e, { ids: [], types: [option.type], create: () => option.create(), newType: option.type });
24
+ }
25
+
26
+ interface Source { ids: string[]; types: string[]; create?: () => BNode; newType?: string }
27
+
28
+ function begin(ctx: EditorContextValue, e: ReactPointerEvent, src: Source) {
29
+ const { ui, store } = ctx;
30
+ const sx = e.clientX, sy = e.clientY;
31
+ const handle = e.currentTarget as HTMLElement;
32
+ let started = false;
33
+ let scrollTimer = 0;
34
+ const pointerId = e.pointerId;
35
+
36
+ const move = (ev: PointerEvent) => {
37
+ const { x, y } = toParent(ctx, ev);
38
+ if (!started) {
39
+ if (Math.hypot(x - sx, y - sy) < THRESHOLD) return;
40
+ started = true;
41
+ try { handle.setPointerCapture(pointerId); } catch { /* đã thả */ }
42
+ document.body.classList.add("is-dragging");
43
+ ui.canvasDoc?.body.classList.add("is-dragging");
44
+ for (const id of src.ids) ui.blockEl(id)?.classList.add("is-dragging-source");
45
+ }
46
+ const target = unlocked(store, findTarget(ctx, x, y, src));
47
+ ui.setDrag({ ids: src.ids, newType: src.newType, x, y, target });
48
+ autoScroll(ctx, y);
49
+ };
50
+ const cleanup = () => {
51
+ document.removeEventListener("pointermove", move);
52
+ document.removeEventListener("pointerup", up);
53
+ document.removeEventListener("keydown", key, true);
54
+ document.removeEventListener("pointercancel", cancel);
55
+ window.removeEventListener("blur", cancel);
56
+ ui.canvasDoc?.removeEventListener("pointermove", move);
57
+ ui.canvasDoc?.removeEventListener("pointerup", up);
58
+ document.body.classList.remove("is-dragging");
59
+ ui.canvasDoc?.body.classList.remove("is-dragging");
60
+ for (const id of src.ids) ui.blockEl(id)?.classList.remove("is-dragging-source");
61
+ clearInterval(scrollTimer);
62
+ try { handle.releasePointerCapture(pointerId); } catch { /* không giữ */ }
63
+ };
64
+ const up = (ev: PointerEvent) => {
65
+ const wasStarted = started;
66
+ const target = started ? unlocked(store, findTarget(ctx, toParent(ctx, ev).x, toParent(ctx, ev).y, src)) : null;
67
+ cleanup();
68
+ ui.setDrag(null);
69
+ if (!wasStarted || !target) return;
70
+ if (src.create) store.insert(target.docId, target.parentId, target.index, [src.create()]);
71
+ else store.moveTo(src.ids, target.docId, target.parentId, target.index);
72
+ // Không để click sau khi thả chèn thêm khối (thư viện khối)
73
+ handle.addEventListener("click", (c) => { c.stopPropagation(); c.preventDefault(); }, { capture: true, once: true });
74
+ };
75
+ const key = (ev: KeyboardEvent) => {
76
+ if (ev.key !== "Escape") return;
77
+ ev.preventDefault();
78
+ cleanup();
79
+ ui.setDrag(null);
80
+ };
81
+ // Kéo bị huỷ (mất con trỏ, đổi cửa sổ) → bỏ kéo, không để nhãn kéo kẹt trên màn hình
82
+ const cancel = () => { cleanup(); ui.setDrag(null); };
83
+ document.addEventListener("pointercancel", cancel);
84
+ window.addEventListener("blur", cancel);
85
+ document.addEventListener("pointermove", move);
86
+ document.addEventListener("pointerup", up);
87
+ document.addEventListener("keydown", key, true);
88
+ ui.canvasDoc?.addEventListener("pointermove", move);
89
+ ui.canvasDoc?.addEventListener("pointerup", up);
90
+
91
+ function autoScroll(c: EditorContextValue, y: number) {
92
+ const f = c.ui.canvasFrame?.getBoundingClientRect();
93
+ clearInterval(scrollTimer);
94
+ if (!f) return;
95
+ const win = c.ui.canvasDoc?.defaultView;
96
+ const edge = 60;
97
+ const dy = y < f.top + edge ? -12 : y > f.bottom - edge ? 12 : 0;
98
+ if (dy && win) scrollTimer = window.setInterval(() => win.scrollBy(0, dy), 16);
99
+ }
100
+ }
101
+
102
+ /** Sự kiện trong iframe có toạ độ theo iframe → đổi sang toạ độ trang ngoài. */
103
+ function toParent(ctx: EditorContextValue, ev: PointerEvent) {
104
+ const view = (ev.target as Node | null)?.ownerDocument;
105
+ if (view && view === ctx.ui.canvasDoc && ctx.ui.canvasFrame) {
106
+ const f = ctx.ui.canvasFrame.getBoundingClientRect();
107
+ const scale = f.width / (ctx.ui.canvasFrame.offsetWidth || f.width) || 1;
108
+ return { x: f.left + ev.clientX * scale, y: f.top + ev.clientY * scale };
109
+ }
110
+ return { x: ev.clientX, y: ev.clientY };
111
+ }
112
+
113
+ function findTarget(ctx: EditorContextValue, x: number, y: number, src: Source): DropTarget | null {
114
+ const { ui, store } = ctx;
115
+ const frame = ui.canvasFrame, doc = ui.canvasDoc;
116
+ if (!frame || !doc) return null;
117
+ const f = frame.getBoundingClientRect();
118
+ if (x < f.left || x > f.right || y < f.top || y > f.bottom) return null;
119
+ const scale = f.width / (frame.offsetWidth || f.width) || 1;
120
+ const ix = (x - f.left) / scale, iy = (y - f.top) / scale;
121
+ const toParentRect = (r: DOMRect) => ({ left: f.left + r.left * scale, top: f.top + r.top * scale, width: r.width * scale, height: r.height * scale });
122
+
123
+ let el = doc.elementFromPoint(ix, iy) as HTMLElement | null;
124
+ let blockEl = el?.closest<HTMLElement>("[data-ecx-block]") ?? null;
125
+ // Không thả vào chính khối đang kéo / con của nó
126
+ while (blockEl && src.ids.some((id) => blockEl!.dataset.ecxBlock === id || isInside(store, blockEl!.dataset.ecxBlock!, id))) {
127
+ blockEl = blockEl.parentElement?.closest<HTMLElement>("[data-ecx-block]") ?? null;
128
+ }
129
+ if (!blockEl) {
130
+ // Ngoài mọi khối: thả vào cuối / đầu tài liệu đang hiện, theo khối cấp cao nhất gần nhất
131
+ const docId = store.activeDocId;
132
+ const top = store.getState().docs[docId]?.blocks ?? [];
133
+ if (!top.length) return validate(store, src, { docId, parentId: null, index: 0, rect: toParentRect(doc.querySelector(".ecx-canvas-root")!.getBoundingClientRect()), horizontal: false });
134
+ let idx = top.length;
135
+ for (let i = 0; i < top.length; i++) {
136
+ const r = ui.blockEl(top[i].id)?.getBoundingClientRect();
137
+ if (r && iy < r.top + r.height / 2) { idx = i; break; }
138
+ }
139
+ const ref = ui.blockEl(top[Math.min(idx, top.length - 1)].id)!.getBoundingClientRect();
140
+ const lineY = idx < top.length ? ref.top - 2 : ref.bottom + 2;
141
+ return validate(store, src, { docId, parentId: null, index: idx, rect: toParentRect(new DOMRect(ref.left, lineY - 2, ref.width, 4)), horizontal: false });
142
+ }
143
+ void el;
144
+ el = null;
145
+ // Thu nhỏ: chỉ thả giữa các phần (trước / sau khối cấp cao nhất của tài liệu đang sửa)
146
+ if (ui.zoomOut) {
147
+ const sid = sectionOf(store, blockEl);
148
+ const loc = sid ? store.locate(sid) : null;
149
+ if (!loc) return null;
150
+ const r = ui.blockEl(sid!)!.getBoundingClientRect();
151
+ const after = iy > r.top + r.height / 2;
152
+ return validate(store, src, { docId: loc.docId, parentId: null, index: loc.index + (after ? 1 : 0), rect: toParentRect(new DOMRect(r.left, (after ? r.bottom : r.top) - 2, r.width, 4)), horizontal: false });
153
+ }
154
+ let id = blockEl.dataset.ecxBlock!;
155
+ for (let guard = 0; guard < 12; guard++) {
156
+ const loc = store.locate(id);
157
+ if (!loc) return null;
158
+ const node = loc.block;
159
+ const r = ui.blockEl(id)!.getBoundingClientRect();
160
+ // Khối chứa trống (có nút "+") → thả vào trong
161
+ if (node.content && !node.content.length && canContainAll(node.type, src.types)) {
162
+ return { docId: loc.docId, parentId: node.id, index: 0, rect: toParentRect(r), horizontal: false };
163
+ }
164
+ const parentEl = ui.blockEl(id)!.parentElement;
165
+ const horizontal = !!parentEl && isRow(parentEl);
166
+ const after = horizontal ? ix > r.left + r.width / 2 : iy > r.top + r.height / 2;
167
+ const parentType = loc.parent?.type ?? null;
168
+ if (canContainAll(parentType, src.types)) {
169
+ const line = horizontal
170
+ ? new DOMRect((after ? r.right : r.left) - 2, r.top, 4, r.height)
171
+ : new DOMRect(r.left, (after ? r.bottom : r.top) - 2, r.width, 4);
172
+ return { docId: loc.docId, parentId: loc.parent?.id ?? null, index: loc.index + (after ? 1 : 0), rect: toParentRect(line), horizontal };
173
+ }
174
+ if (!loc.parent) return null;
175
+ id = loc.parent.id;
176
+ }
177
+ return null;
178
+ }
179
+
180
+ function validate(store: EditorContextValue["store"], src: Source, t: DropTarget): DropTarget | null {
181
+ const parentType = t.parentId ? store.block(t.parentId)?.type ?? null : null;
182
+ if (store.doc(t.docId)?.mode === "disabled") return null;
183
+ return canContainAll(parentType, src.types) ? t : null;
184
+ }
185
+ const canContainAll = (parentType: string | null, types: string[]) => types.every((t) => canContain(parentType, t));
186
+ /** Chỗ thả bị khoá (templateLock) → không nhận. */
187
+ function unlocked(store: EditorContextValue["store"], t: DropTarget | null): DropTarget | null { return t && store.canInsertInto(t.parentId) ? t : null; }
188
+ const isInside = (store: EditorContextValue["store"], id: string, ancestor: string) => !!store.locate(id)?.ancestors.includes(ancestor);
189
+ function isRow(el: HTMLElement) {
190
+ const s = el.ownerDocument.defaultView!.getComputedStyle(el);
191
+ return (s.display.includes("flex") && !s.flexDirection.startsWith("column")) || (s.display.includes("grid") && s.gridAutoFlow.startsWith("column"));
192
+ }
@@ -0,0 +1,146 @@
1
+ import { createContext, useCallback, useContext, useMemo, useRef, useSyncExternalStore, type ReactNode } from "react";
2
+ import type { EditorStore, EditorState, EditingMode } from "./core/store";
3
+ import type { BlockTypeRegistry } from "./core/registry";
4
+ import type { DynamicData, DynamicPost, EditorHost } from "./core/host";
5
+ import type { V2Labels } from "./labels";
6
+ import type { PrefsStore } from "./prefs";
7
+
8
+ /** Những thứ cả cây React của trình soạn dùng chung (khung soạn trong iframe là portal nên vẫn nhận được context). */
9
+ export interface EditorContextValue {
10
+ store: EditorStore;
11
+ registry: BlockTypeRegistry;
12
+ host: EditorHost;
13
+ labels: V2Labels;
14
+ /** Bộ phận giao diện đăng ký với nhau (khung soạn ↔ thanh công cụ ↔ kéo thả). */
15
+ ui: EditorUi;
16
+ /** Tuỳ chọn trình soạn của người dùng. */
17
+ prefs: PrefsStore;
18
+ }
19
+
20
+ /** Cầu nối giữa khung soạn (iframe) và giao diện bên ngoài. */
21
+ export class EditorUi {
22
+ /** Tài liệu của iframe khung soạn (null khi chưa nạp). */
23
+ canvasDoc: Document | null = null;
24
+ canvasFrame: HTMLIFrameElement | null = null;
25
+ private listeners = new Set<() => void>();
26
+ /** Phiên bản đo lại vị trí (cuộn, đổi cỡ, nạp lại iframe). */
27
+ tick = 0;
28
+ /** Popover chèn khối (slash "/" hoặc nút "+") đang mở. */
29
+ inserter: InserterRequest | null = null;
30
+ drag: DragState | null = null;
31
+ /** Đang gõ chữ: ẩn thanh công cụ cho khỏi che chữ (rê chuột thì hiện lại). */
32
+ typing = false;
33
+ /** Thu nhỏ: cả trang trong tầm nhìn, chỉ chọn / sắp xếp các phần (khối cấp cao nhất). */
34
+ zoomOut = false;
35
+ /** Mở thư viện khối đầy đủ (cột trái) — nút "Xem tất cả" của chèn nhanh; ứng dụng / BlockEditor gán. */
36
+ browseAll: (() => void) | null = null;
37
+ setZoomOut(v: boolean) { if (this.zoomOut !== v) { this.zoomOut = v; this.bump(); } }
38
+ setTyping(v: boolean) { if (this.typing !== v) { this.typing = v; this.bump(); } }
39
+ /** Bàn phím của popover chèn khối khi đang gõ "/" (khối chữ chuyển phím lên/xuống/Enter/Esc sang). */
40
+ inserterKey: ((key: string) => boolean) | null = null;
41
+ /** Ô gõ đang có focus (khoá richViews: "blockId" hoặc "blockId#field"). */
42
+ activeRich: string | null = null;
43
+ /** Mở hộp sửa liên kết cho ô gõ (khoá richViews). */
44
+ openLink: ((viewKey: string) => void) | null = null;
45
+
46
+ subscribe = (l: () => void) => { this.listeners.add(l); return () => { this.listeners.delete(l); }; };
47
+ getTick = () => this.tick;
48
+ bump() { this.tick++; this.listeners.forEach((l) => l()); }
49
+
50
+ /** Phần tử DOM của khối trong khung soạn. */
51
+ blockEl(id: string): HTMLElement | null {
52
+ return this.canvasDoc?.querySelector<HTMLElement>(`[data-ecx-block="${CSS.escape(id)}"]`) ?? null;
53
+ }
54
+ /** Khung chữ nhật của khối theo toạ độ trang ngoài (cộng vị trí iframe). */
55
+ blockRect(id: string): DOMRect | null {
56
+ const el = this.blockEl(id);
57
+ if (!el || !this.canvasFrame) return null;
58
+ const r = el.getBoundingClientRect();
59
+ const f = this.canvasFrame.getBoundingClientRect();
60
+ const scale = f.width / (this.canvasFrame.offsetWidth || f.width) || 1;
61
+ return new DOMRect(f.left + r.left * scale, f.top + r.top * scale, r.width * scale, r.height * scale);
62
+ }
63
+ openInserter(req: InserterRequest | null) { this.inserter = req; this.bump(); }
64
+ /** Thông báo cho trình đọc màn hình (vùng aria-live). */
65
+ announcement = "";
66
+ announce(text: string) { this.announcement = ""; this.bump(); setTimeout(() => { this.announcement = text; this.bump(); }, 30); }
67
+ /** Alt+F10: đưa bàn phím lên thanh công cụ của khối. */
68
+ focusToolbar() { document.querySelector<HTMLElement>(".ecx-toolbar button:not(:disabled)")?.focus(); }
69
+ setDrag(d: DragState | null) { this.drag = d; this.bump(); }
70
+ }
71
+
72
+ export interface InserterRequest {
73
+ /** "slash" = gõ "/" trong đoạn trống (chữ sau "/" là từ khoá), "appender" = nút "+", "between" = chèn giữa hai khối. */
74
+ mode: "slash" | "appender" | "between";
75
+ docId: string;
76
+ parentId: string | null;
77
+ index: number;
78
+ /** Khối chữ đang gõ "/" (slash) — chọn xong thì thay khối này. */
79
+ blockId?: string;
80
+ query?: string;
81
+ /** Neo popover (toạ độ trang ngoài). */
82
+ rect: { left: number; top: number; bottom: number };
83
+ }
84
+
85
+ export interface DragState {
86
+ ids: string[];
87
+ /** Khối mới kéo từ thư viện (chưa có trong tài liệu). */
88
+ newType?: string;
89
+ x: number;
90
+ y: number;
91
+ target: DropTarget | null;
92
+ }
93
+ export interface DropTarget { docId: string; parentId: string | null; index: number; rect: { left: number; top: number; width: number; height: number }; horizontal: boolean }
94
+
95
+ export const EditorContext = createContext<EditorContextValue | null>(null);
96
+ export function useEditor(): EditorContextValue {
97
+ const v = useContext(EditorContext);
98
+ if (!v) throw new Error("ecomweb-editor/v2: thiếu <EditorProvider>");
99
+ return v;
100
+ }
101
+
102
+ /** Đọc một phần trạng thái; chỉ vẽ lại khi phần đó đổi (so sánh ===, hoặc hàm so sánh riêng). */
103
+ export function useEditorState<T>(select: (s: EditorState) => T, equal: (a: T, b: T) => boolean = Object.is): T {
104
+ const { store } = useEditor();
105
+ // Bộ đệm theo cả trạng thái LẪN hàm chọn: useSyncExternalStore gọi hàm chọn cũ với trạng thái mới trước khi vẽ lại
106
+ // (vd đổi tài liệu đang xem) — chỉ so trạng thái sẽ trả về giá trị của hàm chọn cũ.
107
+ const last = useRef<{ s: EditorState; select: (s: EditorState) => T; v: T } | null>(null);
108
+ const get = useCallback(() => {
109
+ const s = store.getState();
110
+ if (last.current && last.current.s === s && last.current.select === select) return last.current.v;
111
+ const v = select(s);
112
+ if (last.current && equal(last.current.v, v)) { last.current = { s, select, v: last.current.v }; return last.current.v; }
113
+ last.current = { s, select, v };
114
+ return v;
115
+ // eslint-disable-next-line react-hooks/exhaustive-deps
116
+ }, [store, select]);
117
+ return useSyncExternalStore(store.subscribe, get, get);
118
+ }
119
+ export const shallowArray = <T,>(a: readonly T[], b: readonly T[]) => a.length === b.length && a.every((x, i) => x === b[i]);
120
+
121
+ export function useUiTick(): number {
122
+ const { ui } = useEditor();
123
+ return useSyncExternalStore(ui.subscribe, ui.getTick, ui.getTick);
124
+ }
125
+
126
+ /** Tài liệu + chế độ sửa của vùng đang vẽ (khối trong header lồng trong template nhận docId của header). */
127
+ export interface DocScope { docId: string; mode: EditingMode; depth: number; /** Các tài liệu bao ngoài (chống lồng vòng tròn: header chứa chính nó). */ chain?: string[] }
128
+ export const DocScopeContext = createContext<DocScope>({ docId: "root", mode: "default", depth: 0 });
129
+ export const useDocScope = () => useContext(DocScopeContext);
130
+
131
+ export function DocScopeProvider({ value, children }: { value: DocScope; children: ReactNode }) {
132
+ // Giữ nguyên object khi nội dung không đổi: mọi khối đọc context này — object mới mỗi lần vẽ = vẽ lại cả tài liệu mỗi phím gõ
133
+ const chain = (value.chain ?? []).join("|");
134
+ // eslint-disable-next-line react-hooks/exhaustive-deps
135
+ const stable = useMemo(() => value, [value.docId, value.mode, value.depth, chain]);
136
+ return <DocScopeContext.Provider value={stable}>{children}</DocScopeContext.Provider>;
137
+ }
138
+
139
+ /** Bài của mục đang vẽ trong "Danh sách bài" — khối bài (tiêu đề, ảnh…) và gắn dữ liệu core/post đọc bài này. */
140
+ export const LoopPostContext = createContext<DynamicPost | null>(null);
141
+ /** Dữ liệu động của chỗ đang vẽ: host.dynamic, với `post` là bài của mục danh sách bài (nếu nằm trong). */
142
+ export function useDynamicData(): DynamicData {
143
+ const { host } = useEditor();
144
+ const post = useContext(LoopPostContext);
145
+ return useMemo(() => (post ? { ...host.dynamic, post } : host.dynamic ?? {}), [host.dynamic, post]);
146
+ }
@@ -0,0 +1,64 @@
1
+ import type { DynamicData } from "./host";
2
+ import type { BNode } from "./model";
3
+
4
+ /**
5
+ * Gắn dữ liệu trong trình soạn (attrs.bindings, @ecomcx/ecomweb-content 1.15): chọn nguồn cho thuộc tính của khối, xem trước giá trị.
6
+ * Website lấy giá trị thật lúc hiển thị (theme-sdk: CORE_BINDING_SOURCES + bindingSources của plugin).
7
+ * Plugin đăng ký nguồn cho trình soạn: registerBindingSource (admin-sdk) — tên trùng với nguồn phía website.
8
+ */
9
+ export interface EditorBindingSource {
10
+ /** "nhóm/tên" — trùng tên nguồn phía website. */
11
+ name: string;
12
+ label: string;
13
+ /** Trường chọn được (đặt vào args[argKey]). Không có → ô nhập tự do. */
14
+ fields?: Array<{ value: string; label: string }>;
15
+ /** Tham số do ô chọn / ô nhập đặt (mặc định "field"). */
16
+ argKey?: string;
17
+ /** Chỉ cho các thuộc tính này (vd ["src"] cho nguồn ảnh). Mặc định mọi thuộc tính gắn được. */
18
+ attributes?: string[];
19
+ /** Giá trị xem trước trong trình soạn (dữ liệu mẫu của trang đang sửa). */
20
+ preview?(args: Record<string, string | number | boolean>, ctx: { dynamic?: DynamicData }): string | undefined | Promise<string | undefined>;
21
+ }
22
+
23
+ export interface Binding { source: string; args?: Record<string, string | number | boolean> }
24
+
25
+ /** Thuộc tính gắn được của khối lõi; khối plugin khai báo bằng BlockType.bindable. */
26
+ export const CORE_BINDABLE: Record<string, string[]> = { paragraph: ["content"], heading: ["content"], image: ["src", "alt", "caption"], button: ["text", "href"] };
27
+
28
+ const sources = new Map<string, EditorBindingSource>();
29
+ const listeners = new Set<() => void>();
30
+ let snapshot: EditorBindingSource[] = [];
31
+ const changed = () => { snapshot = [...sources.values()]; listeners.forEach((l) => l()); };
32
+ export function registerBindingSource(src: EditorBindingSource) { sources.set(src.name, src); changed(); }
33
+ export function unregisterBindingSource(name: string) { if (sources.delete(name)) changed(); }
34
+ export const bindingSources = () => snapshot;
35
+ export const bindingSource = (name: string) => sources.get(name);
36
+ export const subscribeBindingSources = (l: () => void) => { listeners.add(l); return () => { listeners.delete(l); }; };
37
+
38
+ /** Nguồn lõi (trùng tên với CORE_BINDING_SOURCES của theme-sdk). Nhãn theo ngôn ngữ. */
39
+ export function registerCoreBindingSources(lang: "vi" | "en") {
40
+ const vi = lang === "vi";
41
+ registerBindingSource({
42
+ name: "core/post", label: vi ? "Bài đang xem" : "Current post",
43
+ fields: [
44
+ { value: "title", label: vi ? "Tiêu đề" : "Title" }, { value: "excerpt", label: vi ? "Tóm tắt" : "Excerpt" }, { value: "date", label: vi ? "Ngày đăng" : "Date" },
45
+ { value: "author", label: vi ? "Tác giả" : "Author" }, { value: "link", label: vi ? "Đường dẫn" : "Link" }, { value: "featuredImage", label: vi ? "Ảnh đại diện" : "Featured image" },
46
+ ],
47
+ preview: (args, { dynamic }) => {
48
+ const p = dynamic?.post;
49
+ switch (args.field) {
50
+ case "title": return p?.title; case "excerpt": return p?.excerpt; case "date": return p?.date; case "author": return p?.author;
51
+ case "featuredImage": return p?.image ?? undefined; case "link": return "/…";
52
+ default: return undefined;
53
+ }
54
+ },
55
+ });
56
+ registerBindingSource({ name: "core/post-meta", label: vi ? "Trường meta của bài" : "Post meta field", argKey: "key", preview: (args) => (args.key ? `{${args.key}}` : undefined) });
57
+ registerBindingSource({
58
+ name: "core/site", label: vi ? "Website" : "Site",
59
+ fields: [{ value: "title", label: vi ? "Tên website" : "Site title" }, { value: "tagline", label: vi ? "Khẩu hiệu" : "Tagline" }, { value: "url", label: "URL" }, { value: "logo", label: "Logo" }],
60
+ preview: (args, { dynamic }) => (args.field === "title" ? dynamic?.site?.title : args.field === "tagline" ? dynamic?.site?.tagline : args.field === "logo" ? dynamic?.site?.logo ?? undefined : undefined),
61
+ });
62
+ }
63
+
64
+ export const bindingsOf = (b: BNode) => (b.attrs.bindings as Record<string, Binding> | undefined) ?? undefined;
@@ -0,0 +1,238 @@
1
+ import { isSafeUrl, type RichMark, type RichNode } from "@ecomcx/ecomweb-content";
2
+ import { cleanPastedHtml } from "../../shared/paste";
3
+ import { blocksFromDoc, cloneBlock, docFromBlocks, fromRich, inlineLength, inlineText, makeBlock, splitInline, toRich, type BNode } from "./model";
4
+ import { flatten } from "./ops";
5
+ import type { EditorStore } from "./store";
6
+
7
+ /** Kiểu dữ liệu clipboard riêng: chép khối giữa các trình soạn giữ nguyên cấu trúc + thuộc tính. */
8
+ export const BLOCKS_MIME = "application/x-ecx-blocks";
9
+
10
+ // ---------------------------------------------------------------------------
11
+ // HTML → khối
12
+ // ---------------------------------------------------------------------------
13
+ const MARK_TAGS: Record<string, string> = { STRONG: "bold", B: "bold", EM: "italic", I: "italic", U: "underline", S: "strike", DEL: "strike", STRIKE: "strike", CODE: "code", SUB: "subscript", SUP: "superscript", MARK: "highlight" };
14
+ const BLOCK_TAGS = new Set(["P", "DIV", "H1", "H2", "H3", "H4", "H5", "H6", "UL", "OL", "LI", "BLOCKQUOTE", "PRE", "HR", "TABLE", "FIGURE", "IMG", "SECTION", "ARTICLE", "HEADER", "FOOTER", "MAIN", "ASIDE", "NAV", "DL", "DT", "DD"]);
15
+
16
+ function inlineOf(node: globalThis.Node, marks: RichMark[] = [], out: RichNode[] = []): RichNode[] {
17
+ node.childNodes.forEach((c) => {
18
+ if (c.nodeType === 3) {
19
+ const text = (c.textContent ?? "").replace(/[\t\n\r ]+/g, " ");
20
+ if (!text) return;
21
+ const last = out[out.length - 1];
22
+ if (last?.type === "text" && JSON.stringify(last.marks ?? []) === JSON.stringify(marks)) last.text += text;
23
+ else out.push(marks.length ? { type: "text", text, marks: [...marks] } : { type: "text", text });
24
+ return;
25
+ }
26
+ if (c.nodeType !== 1) return;
27
+ const el = c as HTMLElement;
28
+ if (el.tagName === "BR") { out.push({ type: "hardBreak" }); return; }
29
+ if (el.tagName === "IMG" || BLOCK_TAGS.has(el.tagName)) { inlineOf(el, marks, out); return; }
30
+ let next = marks;
31
+ const m = MARK_TAGS[el.tagName];
32
+ if (m && !next.some((x) => x.type === m)) next = [...next, { type: m }];
33
+ if (el.tagName === "A") {
34
+ const href = el.getAttribute("href") ?? "";
35
+ if (href && isSafeUrl(href)) next = [...next.filter((x) => x.type !== "link"), { type: "link", attrs: { href } }];
36
+ }
37
+ inlineOf(el, next, out);
38
+ });
39
+ return out;
40
+ }
41
+
42
+ /** Bỏ khoảng trắng thừa ở hai đầu đoạn chữ. */
43
+ function trimInline(inline: RichNode[]): RichNode[] {
44
+ const out = inline.map((n) => ({ ...n }));
45
+ while (out[0]?.type === "hardBreak") out.shift();
46
+ while (out[out.length - 1]?.type === "hardBreak") out.pop();
47
+ if (out[0]?.type === "text") out[0].text = out[0].text!.replace(/^\s+/, "");
48
+ const last = out[out.length - 1];
49
+ if (last?.type === "text") last.text = last.text!.replace(/\s+$/, "");
50
+ return out.filter((n) => n.type !== "text" || n.text);
51
+ }
52
+
53
+ const hasBlockChild = (el: Element) => Array.from(el.children).some((c) => BLOCK_TAGS.has(c.tagName));
54
+
55
+ function blocksOf(el: Element, out: RichNode[] = []): RichNode[] {
56
+ let pending: RichNode[] = [];
57
+ const flush = () => {
58
+ const t = trimInline(pending);
59
+ if (t.length) out.push({ type: "paragraph", content: t });
60
+ pending = [];
61
+ };
62
+ el.childNodes.forEach((c) => {
63
+ if (c.nodeType === 3) { inlineOf({ childNodes: [c] } as unknown as globalThis.Node, [], pending); return; }
64
+ if (c.nodeType !== 1) return;
65
+ const e = c as HTMLElement;
66
+ const tag = e.tagName;
67
+ if (!BLOCK_TAGS.has(tag)) {
68
+ if (tag === "BR") pending.push({ type: "hardBreak" });
69
+ else if (!["SCRIPT", "STYLE", "META", "LINK", "TITLE", "HEAD"].includes(tag)) inlineOf({ childNodes: [e] } as unknown as globalThis.Node, [], pending);
70
+ return;
71
+ }
72
+ flush();
73
+ const node = blockOf(e);
74
+ if (Array.isArray(node)) out.push(...node);
75
+ else if (node) out.push(node);
76
+ });
77
+ flush();
78
+ return out;
79
+ }
80
+
81
+ function blockOf(e: HTMLElement): RichNode | RichNode[] | null {
82
+ const tag = e.tagName;
83
+ const text = (inline: RichNode[]) => { const t = trimInline(inline); return t.length ? { content: t } : {}; };
84
+ switch (tag) {
85
+ case "H1": case "H2": case "H3": case "H4": case "H5": case "H6":
86
+ return { type: "heading", attrs: { level: Number(tag[1]) }, ...text(inlineOf(e)) };
87
+ case "P":
88
+ return hasBlockChild(e) ? blocksOf(e) : { type: "paragraph", ...text(inlineOf(e)) };
89
+ case "UL": case "OL": {
90
+ const items = Array.from(e.children).filter((c) => c.tagName === "LI").map((li) => {
91
+ const kids = blocksOf(li);
92
+ if (!kids.length || kids[0].type !== "paragraph") kids.unshift({ type: "paragraph" });
93
+ return { type: "listItem", content: kids };
94
+ });
95
+ if (!items.length) return null;
96
+ const start = Number(e.getAttribute("start"));
97
+ return { type: tag === "UL" ? "bulletList" : "orderedList", ...(tag === "OL" && start > 1 ? { attrs: { start } } : {}), content: items };
98
+ }
99
+ case "BLOCKQUOTE": {
100
+ const kids = blocksOf(e);
101
+ return kids.length ? { type: "blockquote", content: kids } : null;
102
+ }
103
+ case "PRE": {
104
+ const code = (e.textContent ?? "").replace(/\n$/, "");
105
+ return { type: "codeBlock", ...(code ? { content: [{ type: "text", text: code }] } : {}) };
106
+ }
107
+ case "HR": return { type: "horizontalRule" };
108
+ case "IMG": {
109
+ const src = e.getAttribute("src") ?? "";
110
+ return src && isSafeUrl(src) ? { type: "image", attrs: { src, alt: e.getAttribute("alt") ?? undefined } } : null;
111
+ }
112
+ case "FIGURE": {
113
+ const img = e.querySelector("img");
114
+ const cap = e.querySelector("figcaption")?.textContent?.trim();
115
+ const src = img?.getAttribute("src") ?? "";
116
+ if (img && src && isSafeUrl(src)) return { type: "image", attrs: { src, alt: img.getAttribute("alt") ?? undefined, ...(cap ? { caption: cap } : {}) } };
117
+ return blocksOf(e);
118
+ }
119
+ case "TABLE": {
120
+ const rows = Array.from(e.querySelectorAll("tr")).filter((tr) => tr.closest("table") === e).map((tr) => ({
121
+ type: "tableRow",
122
+ content: Array.from(tr.children).filter((c) => c.tagName === "TD" || c.tagName === "TH").map((cell) => {
123
+ const kids = blocksOf(cell);
124
+ const span = (n: string) => Number(cell.getAttribute(n)) > 1 ? Number(cell.getAttribute(n)) : undefined;
125
+ const attrs = Object.fromEntries(Object.entries({ colspan: span("colspan"), rowspan: span("rowspan") }).filter(([, v]) => v));
126
+ return { type: cell.tagName === "TH" ? "tableHeader" : "tableCell", ...(Object.keys(attrs).length ? { attrs } : {}), content: kids.length ? kids : [{ type: "paragraph" }] };
127
+ }),
128
+ })).filter((r) => r.content.length);
129
+ return rows.length ? { type: "table", content: rows } : null;
130
+ }
131
+ default:
132
+ // div, section…: chỉ có chữ → đoạn văn; có khối con → đi vào trong
133
+ return hasBlockChild(e) ? blocksOf(e) : { type: "paragraph", ...text(inlineOf(e)) };
134
+ }
135
+ }
136
+
137
+ /** HTML (Word, Google Docs, trang web) → danh sách khối RichNode. */
138
+ export function htmlToRich(html: string): RichNode[] {
139
+ if (typeof DOMParser === "undefined") return [];
140
+ const doc = new DOMParser().parseFromString(cleanPastedHtml(html), "text/html");
141
+ return blocksOf(doc.body).filter((n) => !(n.type === "paragraph" && !n.content?.length));
142
+ }
143
+
144
+ /** Chữ thuần nhiều dòng → đoạn văn (dòng trống tách đoạn; xuống dòng đơn trong đoạn = hardBreak). */
145
+ export function textToRich(text: string): RichNode[] {
146
+ return text.replace(/\r\n?/g, "\n").split(/\n{2,}/).map((para) => {
147
+ const lines = para.split("\n");
148
+ const content: RichNode[] = [];
149
+ lines.forEach((l, i) => { if (i) content.push({ type: "hardBreak" }); if (l) content.push({ type: "text", text: l }); });
150
+ return content.length ? { type: "paragraph", content } : { type: "paragraph" };
151
+ }).filter((p) => p.content);
152
+ }
153
+
154
+ // ---------------------------------------------------------------------------
155
+ // Dán vào khối chữ
156
+ // ---------------------------------------------------------------------------
157
+ /** Chèn các khối tại vị trí con trỏ trong khối chữ: tách khối, chèn giữa; khối trống thì thay luôn. */
158
+ export function insertBlocksAtCaret(store: EditorStore, blockId: string, from: number, to: number, nodes: BNode[]) {
159
+ const loc = store.locate(blockId);
160
+ if (!loc?.block.inline || !nodes.length) return;
161
+ const b = loc.block;
162
+ const [before] = splitInline(b.inline!, from);
163
+ const [, after] = splitInline(b.inline!, to);
164
+ const parentId = loc.parent?.id ?? null;
165
+ const lastText = [...flatten(nodes)].reverse().find((n) => n.inline);
166
+ const caret = lastText ? { id: lastText.id, offset: inlineLength(lastText.inline) } : null;
167
+ const replacement: BNode[] = [];
168
+ if (inlineLength(before)) replacement.push({ ...b, inline: before });
169
+ replacement.push(...nodes);
170
+ if (inlineLength(after)) replacement.push(makeBlock(b.type, { ...b.attrs }, after));
171
+ store.commit(loc.docId, replaceAt(store.getState().docs[loc.docId].blocks, parentId, loc.index, replacement), {
172
+ select: caret ? { ids: [], editing: caret.id } : { ids: nodes.map((n) => n.id), editing: null }, caret,
173
+ });
174
+ }
175
+
176
+ function replaceAt(blocks: BNode[], parentId: string | null, index: number, nodes: BNode[]): BNode[] {
177
+ const swap = (list: BNode[]) => [...list.slice(0, index), ...nodes, ...list.slice(index + 1)];
178
+ if (parentId == null) return swap(blocks);
179
+ const walk = (list: BNode[]): BNode[] => list.map((x) => (x.id === parentId ? { ...x, content: swap(x.content!) } : x.content ? { ...x, content: walk(x.content) } : x));
180
+ return walk(blocks);
181
+ }
182
+
183
+ export function serializeBlocks(nodes: BNode[]): { json: string; text: string; html: string } {
184
+ const rich = nodes.map(toRich);
185
+ const text = flatten(nodes).filter((n) => n.inline).map((n) => inlineText(n.inline)).join("\n\n");
186
+ return { json: JSON.stringify(rich), text, html: richToHtml(rich) };
187
+ }
188
+
189
+ const esc = (s: string) => s.replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]!);
190
+ const MARK_HTML: Record<string, string> = { bold: "strong", italic: "em", underline: "u", strike: "s", code: "code", subscript: "sub", superscript: "sup", highlight: "mark" };
191
+ /** HTML đơn giản (dán sang Word, email…). */
192
+ export function richToHtml(nodes: RichNode[]): string {
193
+ const inl = (list: RichNode[] = []) => list.map((n) => {
194
+ if (n.type === "hardBreak") return "<br>";
195
+ if (n.type !== "text") return "";
196
+ let s = esc(n.text ?? "");
197
+ for (const m of n.marks ?? []) {
198
+ if (m.type === "link" && typeof m.attrs?.href === "string" && isSafeUrl(m.attrs.href)) s = `<a href="${esc(m.attrs.href)}">${s}</a>`;
199
+ else if (MARK_HTML[m.type]) s = `<${MARK_HTML[m.type]}>${s}</${MARK_HTML[m.type]}>`;
200
+ }
201
+ return s;
202
+ }).join("");
203
+ const blk = (n: RichNode): string => {
204
+ const kids = () => (n.content ?? []).map(blk).join("");
205
+ switch (n.type) {
206
+ case "paragraph": return `<p>${inl(n.content)}</p>`;
207
+ case "heading": return `<h${Number(n.attrs?.level) || 2}>${inl(n.content)}</h${Number(n.attrs?.level) || 2}>`;
208
+ case "bulletList": case "taskList": return `<ul>${kids()}</ul>`;
209
+ case "orderedList": return `<ol>${kids()}</ol>`;
210
+ case "listItem": case "taskItem": return `<li>${kids()}</li>`;
211
+ case "blockquote": return `<blockquote>${kids()}</blockquote>`;
212
+ case "codeBlock": case "preformatted": return `<pre>${esc((n.content ?? []).map((c) => c.text ?? "").join(""))}</pre>`;
213
+ case "horizontalRule": return "<hr>";
214
+ case "image": return typeof n.attrs?.src === "string" && isSafeUrl(n.attrs.src) ? `<img src="${esc(n.attrs.src)}" alt="${esc(String(n.attrs.alt ?? ""))}">` : "";
215
+ case "table": return `<table>${kids()}</table>`;
216
+ case "tableRow": return `<tr>${kids()}</tr>`;
217
+ case "tableCell": return `<td>${kids()}</td>`;
218
+ case "tableHeader": return `<th>${kids()}</th>`;
219
+ default: return n.content?.length ? (n.content.every((c) => c.type === "text" || c.type === "hardBreak") ? `<p>${inl(n.content)}</p>` : `<div>${kids()}</div>`) : "";
220
+ }
221
+ };
222
+ return nodes.map(blk).join("");
223
+ }
224
+
225
+ /** Đọc khối từ clipboard (dán khi đang chọn khối, không gõ chữ). */
226
+ export function blocksFromClipboard(data: DataTransfer): BNode[] {
227
+ const json = data.getData(BLOCKS_MIME);
228
+ if (json) {
229
+ try { return (JSON.parse(json) as RichNode[]).map(fromRich); } catch { /* bỏ qua */ }
230
+ }
231
+ const html = data.getData("text/html");
232
+ if (html) { const r = htmlToRich(html); if (r.length) return r.map(fromRich); }
233
+ const text = data.getData("text/plain");
234
+ return text ? textToRich(text).map(fromRich) : [];
235
+ }
236
+
237
+ export const cloneAll = (nodes: BNode[]) => nodes.map(cloneBlock);
238
+ export { blocksFromDoc, docFromBlocks };