@libs-ui/components-preview-text-data 0.2.357-3 → 0.2.357-4

package/README.md

@@ -276,6 +276,50 @@ function calculateTotal(items) {
   [langsAccept]="['json']" />
 ```
 
+### 6. Màn nhập code (min/max số dòng + giới hạn ngôn ngữ)
+
+```typescript
+// component.ts
+import { Component, signal } from '@angular/core';
+import { LibsUiComponentsPreviewTextDataComponent, PREVIEW_TEXT_DATA_LANGUAGE_SUPPORT } from '@libs-ui/components-preview-text-data';
+
+@Component({
+  selector: 'app-code-input',
+  standalone: true,
+  imports: [LibsUiComponentsPreviewTextDataComponent],
+  template: `
+    <libs_ui-components-preview_text_data
+      [content]="''"
+      [(langSelected)]="lang"
+      [editable]="true"
+      [langsAccept]="['javascript', 'python']"
+      [minLines]="10"
+      [maxLines]="20"
+      [zIndexPopover]="1500" />
+  `,
+})
+export class CodeInputComponent {
+  // Mặc định trống, chỉ cho JS/Python; editor hiện sẵn tối thiểu 10 dòng, vượt 20 dòng → xuất hiện scroll.
+  readonly lang = signal<PREVIEW_TEXT_DATA_LANGUAGE_SUPPORT>('javascript');
+}
+```
+
+### 7. Editor tự fit theo container (min/max-height)
+
+Thay vì truyền `minLines`/`maxLines`, bọc editor trong 1 div có `min-height`/`max-height` rồi truyền chính element đó qua `[containerElement]`. Editor tự tính số dòng và snap chiều cao theo container. **Không** dùng chung với `minLines`/`maxLines` (sẽ throw lỗi).
+
+```html
+<!-- #boxRef là template reference tới div container -->
+<div #boxRef class="min-h-[120px] max-h-[300px]">
+  <libs_ui-components-preview_text_data
+    [content]="''"
+    [(langSelected)]="lang"
+    [editable]="true"
+    [langsAccept]="['javascript', 'python']"
+    [containerElement]="boxRef" />
+</div>
+```
+
 ## @Input()
 
 | Input | Type | Default | Mô tả | Ví dụ |
@@ -290,6 +334,10 @@ function calculateTotal(items) {
 | `[forbiddenPatterns]` | `T_ForbiddenPattern[]` | `[]` | Danh sách pattern bị cấm (string hoặc RegExp). Highlight đỏ khi gõ, chặn paste chứa vi phạm, phát ra `(outViolations)` | `[forbiddenPatterns]="DEFAULT_SECURITY_PATTERNS"` |
 | `[lintIgnorePatterns]` | `string[]` | `['Cannot use import statement...', 'Unexpected token export', 'import ', '@angular/core']` | Danh sách chuỗi lỗi linter JS sẽ bị bỏ qua (ignore) trong quá trình kiểm tra | `[lintIgnorePatterns]="['import ']"` |
 | `[background]` | `string` | `'#f8f9fa'` | Màu nền của vùng soạn thảo (CSS color value) | `background="#ffffff"` |
+| `[minLines]` | `number` | `undefined` | Số dòng tối thiểu. Nếu content ít dòng hơn sẽ tự bù dòng trống (xử lý 1 lần khi khởi tạo editor); đủ/nhiều hơn thì giữ nguyên, không cắt bớt | `[minLines]="10"` |
+| `[maxLines]` | `number` | `undefined` | Số dòng tối đa hiển thị. Vượt quá → editor giới hạn chiều cao và xuất hiện vùng cuộn (đo line-height thật khi khởi tạo) | `[maxLines]="20"` |
+| `[zIndexPopover]` | `number` | `undefined` | z-index cho popover dropdown chọn ngôn ngữ (dùng khi editor nằm trong modal/overlay có z-index cao) | `[zIndexPopover]="1500"` |
+| `[containerElement]` | `HTMLElement` | `undefined` | Element bọc ngoài (đã set `min-height`/`max-height` CSS). Editor snap số dòng theo container: `min-height` → bù dòng trống cho đủ (hiện line-number 1..N), `max-height` → giới hạn + scroll. **CẤM** dùng cùng `[minLines]`/`[maxLines]` (throw lỗi) | `[containerElement]="boxRef"` |
 
 ## @Output()
 

package/editor/editor-completions.d.ts

@@ -0,0 +1,8 @@
+import { Extension } from '@codemirror/state';
+import { IPreviewTextDataCompletionItem } from '../preview-text-data.interfaces';
+/**
+ * Tạo extension autocomplete từ danh sách `items`:
+ * 1. Gõ `obj.` → gợi ý properties của obj (dot-notation).
+ * 2. Gõ ký tự → gợi ý tên biến/object top-level.
+ */
+export declare const buildCompletionExtension: (items: IPreviewTextDataCompletionItem[]) => Extension;

package/editor/editor-forbidden.d.ts

@@ -0,0 +1,8 @@
+import { Extension } from '@codemirror/state';
+import { IPreviewTextDataViolation, T_ForbiddenPattern } from '../preview-text-data.interfaces';
+/**
+ * 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 declare const buildForbiddenExtension: (patterns: T_ForbiddenPattern[], emitViolations: (violations: IPreviewTextDataViolation[]) => void) => Extension;

package/editor/editor-height.d.ts

@@ -0,0 +1,21 @@
+import { EditorView } from '@codemirror/view';
+/** Parse giá trị CSS px → number. Trả về undefined nếu không phải px hợp lệ (vd `none`, `0`). */
+export declare const parsePx: (raw: string) => number | undefined;
+/** 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 declare const applyMinLines: (content: string, minLines?: number) => string;
+/**
+ * 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 declare const applyContainerHeight: (view: EditorView, container: HTMLElement) => void;
+/**
+ * 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 declare const applyMaxHeight: (view: EditorView | undefined, options: {
+    minLines?: number;
+    maxLines?: number;
+    container?: HTMLElement;
+}) => void;

package/esm2022/editor/editor-completions.mjs

@@ -0,0 +1,31 @@
+import { autocompletion } from '@codemirror/autocomplete';
+/**
+ * Tạo extension autocomplete từ danh sách `items`:
+ * 1. Gõ `obj.` → gợi ý properties của obj (dot-notation).
+ * 2. Gõ ký tự → gợi ý tên biến/object top-level.
+ */
+export const buildCompletionExtension = (items) => {
+    const completionSource = (context) => {
+        const dotMatch = context.matchBefore(/\w+\.\w*/);
+        if (dotMatch) {
+            const dotPos = dotMatch.text.indexOf('.');
+            const objectName = dotMatch.text.slice(0, dotPos);
+            const parent = items.find((i) => i.label === objectName);
+            if (parent?.properties?.length) {
+                return {
+                    from: dotMatch.from + dotPos + 1,
+                    options: parent.properties.map((p) => ({ label: p.label, type: p.type ?? 'property', detail: p.detail ?? '', info: p.info ?? '' })),
+                };
+            }
+        }
+        const word = context.matchBefore(/\w*/);
+        if (!word || (word.from === word.to && !context.explicit))
+            return null;
+        return {
+            from: word.from,
+            options: items.map((item) => ({ label: item.label, type: item.type ?? 'variable', detail: item.detail ?? '', info: item.info ?? '' })),
+        };
+    };
+    return autocompletion({ override: [completionSource] });
+};
+//# sourceMappingURL=data:application/json;base64,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

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,87 @@
+/** 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;
+};
+/** 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;
+    }
+    view.requestMeasure({
+        read: (measureView) => {
+            const line = measureView.contentDOM.querySelector('.cm-line');
+            const lineHeight = (line ? line.getBoundingClientRect().height : measureView.defaultLineHeight) || 20;
+            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;
+    }
+    view.requestMeasure({
+        read: (measureView) => {
+            const line = measureView.contentDOM.querySelector('.cm-line');
+            return (line ? line.getBoundingClientRect().height : measureView.defaultLineHeight) || 20;
+        },
+        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/** 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  view.requestMeasure({\n    read: (measureView) => {\n      const line = measureView.contentDOM.querySelector('.cm-line');\n      const lineHeight = (line ? line.getBoundingClientRect().height : measureView.defaultLineHeight) || 20;\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  view.requestMeasure({\n    read: (measureView) => {\n      const line = measureView.contentDOM.querySelector('.cm-line');\n      return (line ? line.getBoundingClientRect().height : measureView.defaultLineHeight) || 20;\n    },\n    write: (lineHeight, writeView) => {\n      writeView.scrollDOM.style.maxHeight = `${maxLines * lineHeight + 8}px`;\n      writeView.scrollDOM.style.overflowY = 'auto';\n    },\n  });\n};\n"]}