@libs-ui/components-preview-text-data 0.2.357-2 → 0.2.357-21

package/esm2022/editor/editor-forbidden.mjs

@@ -0,0 +1,65 @@
+import { syntaxTree } from '@codemirror/language';
+import { linter } from '@codemirror/lint';
+import { EditorState, Transaction } from '@codemirror/state';
+const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const toGlobalRegex = (pattern) => {
+    if (pattern instanceof RegExp) {
+        const flags = pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`;
+        return new RegExp(pattern.source, flags);
+    }
+    return new RegExp(escapeRegex(pattern), 'gi');
+};
+/**
+ * Extension bảo mật gồm 2 layer:
+ * 1. Linter: highlight đỏ tại đúng vị trí match (bỏ qua match trong comment) + gọi `emitViolations`.
+ * 2. Transaction filter: chặn paste nếu nội dung paste chứa pattern cấm.
+ */
+export const buildForbiddenExtension = (patterns, emitViolations) => {
+    const forbiddenLinter = linter((view) => {
+        const diagnostics = [];
+        const violations = [];
+        const text = view.state.doc.toString();
+        const commentRanges = [];
+        syntaxTree(view.state).iterate({
+            enter: (node) => {
+                if (node.type.name.toLowerCase().includes('comment')) {
+                    commentRanges.push({ from: node.from, to: node.to });
+                }
+            },
+        });
+        const isInComment = (from, to) => commentRanges.some((r) => from >= r.from && to <= r.to);
+        for (const pattern of patterns) {
+            const re = toGlobalRegex(pattern);
+            re.lastIndex = 0;
+            let match;
+            while ((match = re.exec(text)) !== null) {
+                const from = match.index;
+                const to = from + match[0].length;
+                if (isInComment(from, to))
+                    continue;
+                const line = view.state.doc.lineAt(from).number;
+                const patternLabel = pattern instanceof RegExp ? pattern.source : pattern;
+                diagnostics.push({ from, to, severity: 'error', message: `Mã bị cấm: "${match[0]}" — vi phạm chính sách bảo mật` });
+                violations.push({ from, to, line, pattern: patternLabel, matched: match[0] });
+            }
+        }
+        emitViolations(violations);
+        return diagnostics;
+    });
+    const pasteFilter = EditorState.transactionFilter.of((tr) => {
+        if (!tr.docChanged)
+            return tr;
+        if (!tr.annotation(Transaction.userEvent)?.startsWith('input.paste'))
+            return tr;
+        const newText = tr.newDoc.toString();
+        for (const pattern of patterns) {
+            const re = toGlobalRegex(pattern);
+            re.lastIndex = 0;
+            if (re.test(newText))
+                return [];
+        }
+        return tr;
+    });
+    return [forbiddenLinter, pasteFilter];
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor-forbidden.js","sourceRoot":"","sources":["../../../../../../libs-ui/components/preview-text-data/src/editor/editor-forbidden.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAc,MAAM,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAa,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIxE,MAAM,WAAW,GAAG,CAAC,GAAW,EAAU,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;AAExF,MAAM,aAAa,GAAG,CAAC,OAA2B,EAAU,EAAE;IAC5D,IAAI,OAAO,YAAY,MAAM,EAAE,CAAC;QAC9B,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,GAAG,CAAC;QAChF,OAAO,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC3C,CAAC;IACD,OAAO,IAAI,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,CAAC;AAChD,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,QAA8B,EAAE,cAAiE,EAAa,EAAE;IACtJ,MAAM,eAAe,GAAG,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;QACtC,MAAM,WAAW,GAAiB,EAAE,CAAC;QACrC,MAAM,UAAU,GAAgC,EAAE,CAAC;QACnD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC;QAEvC,MAAM,aAAa,GAAmC,EAAE,CAAC;QACzD,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC;YAC7B,KAAK,EAAE,CAAC,IAAmB,EAAE,EAAE;gBAC7B,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;oBACrD,aAAa,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;gBACvD,CAAC;YACH,CAAC;SACF,CAAC,CAAC;QACH,MAAM,WAAW,GAAG,CAAC,IAAY,EAAE,EAAU,EAAW,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;QAEnH,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;YAC/B,MAAM,EAAE,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;YAClC,EAAE,CAAC,SAAS,GAAG,CAAC,CAAC;YACjB,IAAI,KAA6B,CAAC;YAClC,OAAO,CAAC,KAAK,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;gBACxC,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC;gBACzB,MAAM,EAAE,GAAG,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;gBAClC,IAAI,WAAW,CAAC,IAAI,EAAE,EAAE,CAAC;oBAAE,SAAS;gBACpC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC;gBAChD,MAAM,YAAY,GAAG,OAAO,YAAY,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC;gBAC1E,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,KAAK,CAAC,CAAC,CAAC,gCAAgC,EAAE,CAAC,CAAC;gBACpH,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YAChF,CAAC;QACH,CAAC;QAED,cAAc,CAAC,UAAU,CAAC,CAAC;QAC3B,OAAO,WAAW,CAAC;IACrB,CAAC,CAAC,CAAC;IAEH,MAAM,WAAW,GAAG,WAAW,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC,EAAe,EAAE,EAAE;QACvE,IAAI,CAAC,EAAE,CAAC,UAAU;YAAE,OAAO,EAAE,CAAC;QAC9B,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,aAAa,CAAC;YAAE,OAAO,EAAE,CAAC;QAChF,MAAM,OAAO,GAAG,EAAE,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;QACrC,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;YAC/B,MAAM,EAAE,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;YAClC,EAAE,CAAC,SAAS,GAAG,CAAC,CAAC;YACjB,IAAI,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC;gBAAE,OAAO,EAAE,CAAC;QAClC,CAAC;QACD,OAAO,EAAE,CAAC;IACZ,CAAC,CAAC,CAAC;IAEH,OAAO,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC;AACxC,CAAC,CAAC","sourcesContent":["import { syntaxTree } from '@codemirror/language';\nimport { Diagnostic, linter } from '@codemirror/lint';\nimport { EditorState, Extension, Transaction } from '@codemirror/state';\nimport type { SyntaxNodeRef } from '@lezer/common';\nimport { IPreviewTextDataViolation, T_ForbiddenPattern } from '../preview-text-data.interfaces';\n\nconst escapeRegex = (str: string): string => str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n\nconst toGlobalRegex = (pattern: T_ForbiddenPattern): RegExp => {\n  if (pattern instanceof RegExp) {\n    const flags = pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`;\n    return new RegExp(pattern.source, flags);\n  }\n  return new RegExp(escapeRegex(pattern), 'gi');\n};\n\n/**\n * Extension bảo mật gồm 2 layer:\n * 1. Linter: highlight đỏ tại đúng vị trí match (bỏ qua match trong comment) + gọi `emitViolations`.\n * 2. Transaction filter: chặn paste nếu nội dung paste chứa pattern cấm.\n */\nexport const buildForbiddenExtension = (patterns: T_ForbiddenPattern[], emitViolations: (violations: IPreviewTextDataViolation[]) => void): Extension => {\n  const forbiddenLinter = linter((view) => {\n    const diagnostics: Diagnostic[] = [];\n    const violations: IPreviewTextDataViolation[] = [];\n    const text = view.state.doc.toString();\n\n    const commentRanges: { from: number; to: number }[] = [];\n    syntaxTree(view.state).iterate({\n      enter: (node: SyntaxNodeRef) => {\n        if (node.type.name.toLowerCase().includes('comment')) {\n          commentRanges.push({ from: node.from, to: node.to });\n        }\n      },\n    });\n    const isInComment = (from: number, to: number): boolean => commentRanges.some((r) => from >= r.from && to <= r.to);\n\n    for (const pattern of patterns) {\n      const re = toGlobalRegex(pattern);\n      re.lastIndex = 0;\n      let match: RegExpExecArray | null;\n      while ((match = re.exec(text)) !== null) {\n        const from = match.index;\n        const to = from + match[0].length;\n        if (isInComment(from, to)) continue;\n        const line = view.state.doc.lineAt(from).number;\n        const patternLabel = pattern instanceof RegExp ? pattern.source : pattern;\n        diagnostics.push({ from, to, severity: 'error', message: `Mã bị cấm: \"${match[0]}\" — vi phạm chính sách bảo mật` });\n        violations.push({ from, to, line, pattern: patternLabel, matched: match[0] });\n      }\n    }\n\n    emitViolations(violations);\n    return diagnostics;\n  });\n\n  const pasteFilter = EditorState.transactionFilter.of((tr: Transaction) => {\n    if (!tr.docChanged) return tr;\n    if (!tr.annotation(Transaction.userEvent)?.startsWith('input.paste')) return tr;\n    const newText = tr.newDoc.toString();\n    for (const pattern of patterns) {\n      const re = toGlobalRegex(pattern);\n      re.lastIndex = 0;\n      if (re.test(newText)) return [];\n    }\n    return tr;\n  });\n\n  return [forbiddenLinter, pasteFilter];\n};\n"]}

package/esm2022/editor/editor-height.mjs

@@ -0,0 +1,136 @@
+/** Parse giá trị CSS px → number. Trả về undefined nếu không phải px hợp lệ (vd `none`, `0`). */
+export const parsePx = (raw) => {
+    if (!raw || !raw.endsWith('px')) {
+        return undefined;
+    }
+    const value = parseFloat(raw);
+    return Number.isFinite(value) && value > 0 ? value : undefined;
+};
+/**
+ * Chiều cao MỘT dòng, lấy từ CSS `line-height` của vùng nội dung.
+ *
+ * 🔴 KHÔNG đo `getBoundingClientRect()` của `.cm-line`: số đó phụ thuộc thời điểm gọi và cho ra
+ * hàng loạt giá trị sai khi editor vừa dựng — đo trên modal 08–09/09/2026 với dòng thật `18.19px`
+ * đã gặp `5.82` · `11.61` · `15.88` · `24` · `59`, mỗi lần mở một số khác. `defaultLineHeight` của
+ * CodeMirror cũng không dùng được vì là số mặc định (20/24px), không theo font sản phẩm.
+ *
+ * `line-height` trong CSS thì có ngay khi phần tử gắn vào DOM và không đổi theo thời điểm đọc.
+ */
+const readLineHeight = (view) => {
+    const style = getComputedStyle(view.contentDOM);
+    const lineHeight = parseFloat(style.lineHeight);
+    if (Number.isFinite(lineHeight) && lineHeight > 0) {
+        return lineHeight;
+    }
+    // `line-height: normal` → suy ra từ cỡ chữ, hệ số 1.4 là mức CodeMirror dùng cho editor.
+    const fontSize = parseFloat(style.fontSize);
+    if (Number.isFinite(fontSize) && fontSize > 0) {
+        return fontSize * 1.4;
+    }
+    return view.defaultLineHeight || 20;
+};
+/**
+ * Chạy `apply` khi đã CÓ dòng thật để đo.
+ *
+ * Vì sao không chỉ chờ `document.fonts.ready`: editor có thể dựng SAU lúc font đã nạp (vd ô JSON chỉ
+ * hiện khi người dùng bấm chạy thử). Lúc đó `fonts.ready` giải quyết ngay nhưng `.cm-line` chưa
+ * render, phép đo rơi vào `defaultLineHeight` — đo 08/09/2026: khung JSON thành 895px (48 dòng)
+ * thay vì 281px. Nên: chờ cả font VÀ dòng đầu tiên xuất hiện, thử lại tối đa `SO_LAN_THU` nhịp.
+ */
+const SO_LAN_THU_DO = 30;
+const runWhenFontReady = (view, apply) => {
+    const fonts = typeof document === 'undefined' ? undefined : document.fonts;
+    const doKhiSanSang = (conLai) => {
+        // Chỉ cần vùng nội dung đã gắn vào DOM là `line-height` đọc được — không cần chờ vẽ dòng.
+        if (view.contentDOM.isConnected) {
+            apply();
+            return;
+        }
+        if (conLai <= 0) {
+            // Hết nhịp chờ vẫn chưa có dòng thật — đo bằng số dự phòng, thà lệch hơn không chặn chiều cao.
+            apply();
+            return;
+        }
+        requestAnimationFrame(() => doKhiSanSang(conLai - 1));
+    };
+    if (!fonts?.ready) {
+        doKhiSanSang(SO_LAN_THU_DO);
+        return;
+    }
+    fonts.ready.then(() => doKhiSanSang(SO_LAN_THU_DO)).catch(() => doKhiSanSang(SO_LAN_THU_DO));
+};
+/** Bù dòng trống cho đủ `minLines` (xử lý 1 lần khi khởi tạo). Đủ rồi giữ nguyên, không cắt bớt. */
+export const applyMinLines = (content, minLines) => {
+    const value = content ?? '';
+    if (!minLines || minLines <= 0) {
+        return value;
+    }
+    const currentLines = value === '' ? 1 : value.split('\n').length;
+    if (currentLines >= minLines) {
+        return value;
+    }
+    return value + '\n'.repeat(minLines - currentLines);
+};
+/**
+ * Tính min/max-height vùng cuộn theo CSS của container ngoài, snap về bội số dòng.
+ * Trừ offset phần header/toolbar (giữa đỉnh container và đỉnh vùng cuộn) để vừa khít container.
+ */
+export const applyContainerHeight = (view, container) => {
+    const style = getComputedStyle(container);
+    const minPx = parsePx(style.minHeight);
+    const maxPx = parsePx(style.maxHeight);
+    if (minPx === undefined && maxPx === undefined) {
+        return;
+    }
+    runWhenFontReady(view, () => view.requestMeasure({
+        read: (measureView) => {
+            const lineHeight = readLineHeight(measureView);
+            const offsetTop = Math.max(measureView.scrollDOM.getBoundingClientRect().top - container.getBoundingClientRect().top, 0);
+            const toLines = (px) => Math.max(1, Math.floor((px - offsetTop - 8) / lineHeight));
+            return { lineHeight, minLines: minPx === undefined ? undefined : toLines(minPx), maxLines: maxPx === undefined ? undefined : toLines(maxPx) };
+        },
+        write: ({ lineHeight, minLines, maxLines }, writeView) => {
+            if (maxLines !== undefined) {
+                writeView.scrollDOM.style.maxHeight = `${maxLines * lineHeight + 8}px`;
+                writeView.scrollDOM.style.overflowY = 'auto';
+            }
+            // min-height: bù dòng trống vào content (hiện đủ line-number 1..N), giống cơ chế minLines.
+            if (minLines !== undefined) {
+                const currentLines = writeView.state.doc.lines;
+                if (currentLines < minLines) {
+                    queueMicrotask(() => writeView.dispatch({ changes: { from: writeView.state.doc.length, insert: '\n'.repeat(minLines - currentLines) } }));
+                }
+            }
+        },
+    }));
+};
+/**
+ * Giới hạn chiều cao editor (xử lý 1 lần). 2 chế độ loại trừ nhau:
+ * - `maxLines`: cap theo số dòng truyền vào.
+ * - `container`: tự tính số dòng theo `min-height`/`max-height` (CSS) của container, snap bội số dòng.
+ * Cấu hình đồng thời `container` + `minLines`/`maxLines` → throw.
+ */
+export const applyMaxHeight = (view, options) => {
+    const { minLines, maxLines, container } = options;
+    if (container && (minLines || maxLines)) {
+        throw new Error('[preview-text-data] CẤM cấu hình [containerElement] cùng [minLines]/[maxLines]. Container tự quản lý min/max height.');
+    }
+    if (!view) {
+        return;
+    }
+    if (container) {
+        applyContainerHeight(view, container);
+        return;
+    }
+    if (!maxLines || maxLines <= 0) {
+        return;
+    }
+    runWhenFontReady(view, () => view.requestMeasure({
+        read: (measureView) => readLineHeight(measureView),
+        write: (lineHeight, writeView) => {
+            writeView.scrollDOM.style.maxHeight = `${maxLines * lineHeight + 8}px`;
+            writeView.scrollDOM.style.overflowY = 'auto';
+        },
+    }));
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"editor-height.js","sourceRoot":"","sources":["../../../../../../libs-ui/components/preview-text-data/src/editor/editor-height.ts"],"names":[],"mappings":"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","sourcesContent":["import { EditorView } from '@codemirror/view';\n\n/** Parse giá trị CSS px → number. Trả về undefined nếu không phải px hợp lệ (vd `none`, `0`). */\nexport const parsePx = (raw: string): number | undefined => {\n  if (!raw || !raw.endsWith('px')) {\n    return undefined;\n  }\n  const value = parseFloat(raw);\n  return Number.isFinite(value) && value > 0 ? value : undefined;\n};\n\n/**\n * Chiều cao MỘT dòng, lấy từ CSS `line-height` của vùng nội dung.\n *\n * 🔴 KHÔNG đo `getBoundingClientRect()` của `.cm-line`: số đó phụ thuộc thời điểm gọi và cho ra\n * hàng loạt giá trị sai khi editor vừa dựng — đo trên modal 08–09/09/2026 với dòng thật `18.19px`\n * đã gặp `5.82` · `11.61` · `15.88` · `24` · `59`, mỗi lần mở một số khác. `defaultLineHeight` của\n * CodeMirror cũng không dùng được vì là số mặc định (20/24px), không theo font sản phẩm.\n *\n * `line-height` trong CSS thì có ngay khi phần tử gắn vào DOM và không đổi theo thời điểm đọc.\n */\nconst readLineHeight = (view: EditorView): number => {\n  const style = getComputedStyle(view.contentDOM);\n  const lineHeight = parseFloat(style.lineHeight);\n\n  if (Number.isFinite(lineHeight) && lineHeight > 0) {\n    return lineHeight;\n  }\n  // `line-height: normal` → suy ra từ cỡ chữ, hệ số 1.4 là mức CodeMirror dùng cho editor.\n  const fontSize = parseFloat(style.fontSize);\n\n  if (Number.isFinite(fontSize) && fontSize > 0) {\n    return fontSize * 1.4;\n  }\n\n  return view.defaultLineHeight || 20;\n};\n\n/**\n * Chạy `apply` khi đã CÓ dòng thật để đo.\n *\n * Vì sao không chỉ chờ `document.fonts.ready`: editor có thể dựng SAU lúc font đã nạp (vd ô JSON chỉ\n * hiện khi người dùng bấm chạy thử). Lúc đó `fonts.ready` giải quyết ngay nhưng `.cm-line` chưa\n * render, phép đo rơi vào `defaultLineHeight` — đo 08/09/2026: khung JSON thành 895px (48 dòng)\n * thay vì 281px. Nên: chờ cả font VÀ dòng đầu tiên xuất hiện, thử lại tối đa `SO_LAN_THU` nhịp.\n */\nconst SO_LAN_THU_DO = 30;\n\nconst runWhenFontReady = (view: EditorView, apply: () => void): void => {\n  const fonts = typeof document === 'undefined' ? undefined : document.fonts;\n  const doKhiSanSang = (conLai: number): void => {\n    // Chỉ cần vùng nội dung đã gắn vào DOM là `line-height` đọc được — không cần chờ vẽ dòng.\n    if (view.contentDOM.isConnected) {\n      apply();\n\n      return;\n    }\n    if (conLai <= 0) {\n      // Hết nhịp chờ vẫn chưa có dòng thật — đo bằng số dự phòng, thà lệch hơn không chặn chiều cao.\n      apply();\n\n      return;\n    }\n    requestAnimationFrame(() => doKhiSanSang(conLai - 1));\n  };\n\n  if (!fonts?.ready) {\n    doKhiSanSang(SO_LAN_THU_DO);\n\n    return;\n  }\n  fonts.ready.then(() => doKhiSanSang(SO_LAN_THU_DO)).catch(() => doKhiSanSang(SO_LAN_THU_DO));\n};\n\n/** Bù dòng trống cho đủ `minLines` (xử lý 1 lần khi khởi tạo). Đủ rồi giữ nguyên, không cắt bớt. */\nexport const applyMinLines = (content: string, minLines?: number): string => {\n  const value = content ?? '';\n  if (!minLines || minLines <= 0) {\n    return value;\n  }\n  const currentLines = value === '' ? 1 : value.split('\\n').length;\n  if (currentLines >= minLines) {\n    return value;\n  }\n  return value + '\\n'.repeat(minLines - currentLines);\n};\n\n/**\n * Tính min/max-height vùng cuộn theo CSS của container ngoài, snap về bội số dòng.\n * Trừ offset phần header/toolbar (giữa đỉnh container và đỉnh vùng cuộn) để vừa khít container.\n */\nexport const applyContainerHeight = (view: EditorView, container: HTMLElement): void => {\n  const style = getComputedStyle(container);\n  const minPx = parsePx(style.minHeight);\n  const maxPx = parsePx(style.maxHeight);\n  if (minPx === undefined && maxPx === undefined) {\n    return;\n  }\n  runWhenFontReady(view, () => view.requestMeasure({\n    read: (measureView) => {\n      const lineHeight = readLineHeight(measureView);\n      const offsetTop = Math.max(measureView.scrollDOM.getBoundingClientRect().top - container.getBoundingClientRect().top, 0);\n      const toLines = (px: number) => Math.max(1, Math.floor((px - offsetTop - 8) / lineHeight));\n      return { lineHeight, minLines: minPx === undefined ? undefined : toLines(minPx), maxLines: maxPx === undefined ? undefined : toLines(maxPx) };\n    },\n    write: ({ lineHeight, minLines, maxLines }, writeView) => {\n      if (maxLines !== undefined) {\n        writeView.scrollDOM.style.maxHeight = `${maxLines * lineHeight + 8}px`;\n        writeView.scrollDOM.style.overflowY = 'auto';\n      }\n      // min-height: bù dòng trống vào content (hiện đủ line-number 1..N), giống cơ chế minLines.\n      if (minLines !== undefined) {\n        const currentLines = writeView.state.doc.lines;\n        if (currentLines < minLines) {\n          queueMicrotask(() => writeView.dispatch({ changes: { from: writeView.state.doc.length, insert: '\\n'.repeat(minLines - currentLines) } }));\n        }\n      }\n    },\n  }));\n};\n\n/**\n * Giới hạn chiều cao editor (xử lý 1 lần). 2 chế độ loại trừ nhau:\n * - `maxLines`: cap theo số dòng truyền vào.\n * - `container`: tự tính số dòng theo `min-height`/`max-height` (CSS) của container, snap bội số dòng.\n * Cấu hình đồng thời `container` + `minLines`/`maxLines` → throw.\n */\nexport const applyMaxHeight = (view: EditorView | undefined, options: { minLines?: number; maxLines?: number; container?: HTMLElement }): void => {\n  const { minLines, maxLines, container } = options;\n  if (container && (minLines || maxLines)) {\n    throw new Error('[preview-text-data] CẤM cấu hình [containerElement] cùng [minLines]/[maxLines]. Container tự quản lý min/max height.');\n  }\n  if (!view) {\n    return;\n  }\n  if (container) {\n    applyContainerHeight(view, container);\n    return;\n  }\n  if (!maxLines || maxLines <= 0) {\n    return;\n  }\n  runWhenFontReady(view, () => view.requestMeasure({\n    read: (measureView) => readLineHeight(measureView),\n    write: (lineHeight, writeView) => {\n      writeView.scrollDOM.style.maxHeight = `${maxLines * lineHeight + 8}px`;\n      writeView.scrollDOM.style.overflowY = 'auto';\n    },\n  }));\n};\n"]}