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

package/esm2022/linters/js-linter.mjs

@@ -0,0 +1,348 @@
+import { get } from '@libs-ui/utils';
+import { astSkipKeys, astTypeKeys, tsValueNodes } from '../preview-text-data.define';
+import { getTokenBefore } from './linter-shared';
+// Cache module-level (chia sẻ giữa các instance editor) — đều immutable, lazy-load 1 lần.
+let babelParserModule;
+let knownGlobalsSet;
+/** Lazy-load + cache module @babel/parser (chỉ tải lần đầu khi lint JS/TS). */
+const getBabelParser = async () => {
+    if (!babelParserModule) {
+        babelParserModule = await import('@babel/parser');
+    }
+    return babelParserModule;
+};
+/** Lazy-load + cache tập biến toàn cục JS/DOM hợp lệ từ package `globals` (JSON thuần, browser-safe). */
+const getKnownGlobals = async () => {
+    if (!knownGlobalsSet) {
+        const globalsModule = (await import('globals'));
+        const globalsData = (globalsModule.default ?? globalsModule);
+        knownGlobalsSet = new Set([...Object.keys(globalsData['builtin'] ?? {}), ...Object.keys(globalsData['browser'] ?? {}), ...Object.keys(globalsData['es2021'] ?? {})]);
+    }
+    return knownGlobalsSet;
+};
+/**
+ * Parse code, trả về vừa danh sách lỗi cú pháp vừa AST (nếu parse sạch).
+ * `errorRecovery` gom nhiều lỗi vào `result.errors`; lỗi nặng vẫn `throw` → bắt thêm ở catch.
+ */
+export const parseJs = (parser, code) => {
+    try {
+        const result = parser.parse(code, {
+            sourceType: 'module',
+            errorRecovery: true,
+            plugins: ['typescript', 'jsx'],
+            allowReturnOutsideFunction: true,
+            allowAwaitOutsideFunction: true,
+            allowImportExportEverywhere: true,
+            allowSuperOutsideMethod: true,
+            allowNewTargetOutsideFunction: true,
+            allowUndeclaredExports: true,
+        });
+        return { errors: result.errors, ast: result };
+    }
+    catch (error) {
+        const loc = get(error, 'loc');
+        const message = get(error, 'message') || 'JavaScript syntax error';
+        return { errors: [{ loc, message }] };
+    }
+};
+/** Giữ cho test/back-compat: chỉ lấy danh sách lỗi cú pháp. */
+export const collectBabelErrors = (parser, code) => parseJs(parser, code).errors;
+/**
+ * Quét text từng dòng, flag dấu "." cuối dòng (incomplete property access) tại ĐÚNG vị trí dấu chấm.
+ * Thu thập `taintedLines` (dòng có trailing dot) + `dotPositions` (offset dấu chấm để vá khi parse).
+ */
+export const collectTrailingDotDiagnostics = (doc, diagnostics, taintedLines, dotPositions) => {
+    for (let lineNumber = 1; lineNumber <= doc.lines; lineNumber++) {
+        const line = doc.line(lineNumber);
+        const trimmed = line.text.trimEnd();
+        const match = /(\w+)\.\s*$/.exec(trimmed);
+        if (!match) {
+            continue;
+        }
+        taintedLines.add(lineNumber);
+        const dotPosition = line.from + trimmed.lastIndexOf('.');
+        dotPositions.push(dotPosition);
+        diagnostics.push({ from: dotPosition, to: dotPosition + 1, severity: 'error', message: `Incomplete property access on "${match[1]}"` });
+    }
+};
+/** Thay các ký tự tại `positions` bằng space, giữ nguyên độ dài chuỗi (để offset không đổi). */
+const replaceCharsWithSpace = (code, positions) => {
+    if (!positions.length) {
+        return code;
+    }
+    const chars = code.split('');
+    for (const position of positions) {
+        if (position >= 0 && position < chars.length) {
+            chars[position] = ' ';
+        }
+    }
+    return chars.join('');
+};
+/** VariableDeclaration ở `for(let i=0;...)` / `for..in` / `for..of` KHÔNG cần `;` cuối. */
+const requiresSemicolon = (nodeType, parentType, keyInParent) => {
+    if (nodeType === 'VariableDeclaration') {
+        if (parentType === 'ForStatement' && keyInParent === 'init')
+            return false;
+        if ((parentType === 'ForInStatement' || parentType === 'ForOfStatement') && keyInParent === 'left')
+            return false;
+    }
+    return true;
+};
+/**
+ * Rule custom "require semicolon": câu lệnh (const/let/return/expression...) không kết thúc bằng `;` → báo lỗi.
+ * Dùng vị trí `node.end` của AST babel; bỏ qua dòng tainted (trailing dot) để không chồng lỗi.
+ */
+export const collectMissingSemicolonDiagnostics = (ast, code, diagnostics, taintedLines) => {
+    const semiNodes = new Set(['ExpressionStatement', 'VariableDeclaration', 'ReturnStatement', 'ThrowStatement', 'BreakStatement', 'ContinueStatement', 'DoWhileStatement', 'DebuggerStatement']);
+    const seen = new Set();
+    const lineOf = (offset) => code.slice(0, offset).split('\n').length;
+    const walk = (node, parentType, keyInParent) => {
+        if (Array.isArray(node)) {
+            for (const item of node)
+                walk(item, parentType, keyInParent);
+            return;
+        }
+        if (!node || typeof node !== 'object')
+            return;
+        const current = node;
+        if (typeof current.type !== 'string')
+            return;
+        if (semiNodes.has(current.type) && requiresSemicolon(current.type, parentType, keyInParent) && typeof current.end === 'number') {
+            const end = Math.min(current.end, code.length);
+            if (end > 0 && code.charAt(end - 1) !== ';' && !seen.has(end) && !taintedLines.has(lineOf(end - 1))) {
+                seen.add(end);
+                diagnostics.push({ from: end - 1, to: end, severity: 'error', message: 'Missing semicolon' });
+            }
+        }
+        for (const childKey of Object.keys(current)) {
+            if (astSkipKeys.has(childKey))
+                continue;
+            walk(current[childKey], current.type, childKey);
+        }
+    };
+    walk(ast.program ?? ast, '', '');
+};
+/** Chuẩn hóa message: thân thiện cho trailing dot + heuristic kiểu cũ cho "Unexpected token"; bỏ hậu tố "(line:col)". */
+export const buildJsErrorMessage = (doc, from, rawMessage) => {
+    const charBefore = from > 0 ? doc.sliceString(from - 1, from) : '';
+    if (charBefore === '.') {
+        const owner = getTokenBefore(doc, from).replace(/\.$/, '');
+        return owner ? `Incomplete property access on "${owner}"` : 'Incomplete property access';
+    }
+    const cleaned = rawMessage.replace(/\s*\(\d+:\d+\)\s*$/, '').trim();
+    if (/missing semicolon/i.test(cleaned)) {
+        return 'Unexpected token — missing operator or separator between expressions';
+    }
+    if (/^unexpected token$/i.test(cleaned)) {
+        const prevToken = getTokenBefore(doc, from);
+        if (prevToken.endsWith('('))
+            return 'Missing closing ")"';
+        if (prevToken.endsWith('['))
+            return 'Missing closing "]"';
+        if (/^function$/i.test(prevToken))
+            return 'Expected function name or "("';
+        if (/^return$/i.test(prevToken))
+            return 'Invalid expression after "return"';
+        if (/^=>$/.test(prevToken))
+            return 'Expected function body after "=>"';
+        if (/^const$|^let$|^var$/i.test(prevToken))
+            return 'Expected variable name';
+    }
+    return `JavaScript syntax error: ${cleaned}`;
+};
+/** Lấy tên binding từ pattern (Identifier, destructuring object/array, default, rest). */
+const collectPatternNames = (node, declared) => {
+    if (!node || typeof node.type !== 'string')
+        return;
+    switch (node.type) {
+        case 'Identifier':
+            if (node.name)
+                declared.add(node.name);
+            return;
+        case 'ObjectPattern':
+            if (node.properties)
+                for (const property of node.properties)
+                    collectPatternNames(property.type === 'RestElement' ? property.argument : property.value, declared);
+            return;
+        case 'ArrayPattern':
+            if (node.elements)
+                for (const element of node.elements)
+                    collectPatternNames(element, declared);
+            return;
+        case 'AssignmentPattern':
+            collectPatternNames(node.left, declared);
+            return;
+        case 'RestElement':
+            collectPatternNames(node.argument, declared);
+            return;
+        case 'TSParameterProperty':
+            collectPatternNames(node.parameter, declared);
+            return;
+        default:
+            return;
+    }
+};
+/** Thu thập tên binding (biến/hàm/class/param/import/enum...) từ 1 node vào tập `declared`. */
+const collectBindingNames = (node, declared) => {
+    switch (node.type) {
+        case 'VariableDeclarator':
+            collectPatternNames(node.id, declared);
+            return;
+        case 'FunctionDeclaration':
+        case 'FunctionExpression':
+        case 'ClassDeclaration':
+        case 'ClassExpression':
+            if (node.id?.name)
+                declared.add(node.id.name);
+            if (node.params)
+                for (const param of node.params)
+                    collectPatternNames(param, declared);
+            return;
+        case 'ArrowFunctionExpression':
+            if (node.params)
+                for (const param of node.params)
+                    collectPatternNames(param, declared);
+            return;
+        case 'CatchClause':
+            collectPatternNames(node.param, declared);
+            return;
+        case 'ImportDefaultSpecifier':
+        case 'ImportNamespaceSpecifier':
+        case 'ImportSpecifier':
+            if (node.local?.name)
+                declared.add(node.local.name);
+            return;
+        case 'TSEnumDeclaration':
+        case 'TSModuleDeclaration':
+            if (node.id?.name)
+                declared.add(node.id.name);
+            return;
+        default:
+            return;
+    }
+};
+/** Xác định 1 Identifier có phải tham chiếu giá trị không (loại property access, key object, declaration id, label...). */
+const isReferenceIdentifier = (parent, keyInParent) => {
+    if (!parent)
+        return true;
+    const parentType = parent.type;
+    if ((parentType === 'MemberExpression' || parentType === 'OptionalMemberExpression') && keyInParent === 'property' && !parent.computed)
+        return false;
+    if ((parentType === 'ObjectProperty' || parentType === 'ObjectMethod' || parentType === 'ClassMethod' || parentType === 'ClassProperty' || parentType === 'ClassPrivateProperty' || parentType === 'PropertyDefinition') && keyInParent === 'key' && !parent.computed)
+        return false;
+    if (keyInParent === 'label')
+        return false;
+    if (parentType === 'TSQualifiedName' && keyInParent === 'right')
+        return false;
+    if (parentType === 'VariableDeclarator' && keyInParent === 'id')
+        return false;
+    if ((parentType === 'FunctionDeclaration' || parentType === 'FunctionExpression' || parentType === 'ClassDeclaration' || parentType === 'ClassExpression') && keyInParent === 'id')
+        return false;
+    if (parentType === 'ImportSpecifier' || parentType === 'ImportDefaultSpecifier' || parentType === 'ImportNamespaceSpecifier' || parentType === 'ExportSpecifier')
+        return false;
+    if (parentType === 'MetaProperty')
+        return false;
+    if (parentType === 'TSEnumMember' && keyInParent === 'id')
+        return false;
+    return true;
+};
+/** Duyệt đệ quy AST: gom binding name vào `declared`, gom identifier tham chiếu vào `references`. */
+const walkAstNode = (node, parent, keyInParent, inType, declared, references) => {
+    if (Array.isArray(node)) {
+        for (const item of node)
+            walkAstNode(item, parent, keyInParent, inType, declared, references);
+        return;
+    }
+    if (!node || typeof node !== 'object')
+        return;
+    const current = node;
+    if (typeof current.type !== 'string')
+        return;
+    collectBindingNames(current, declared);
+    if (current.type === 'Identifier' && !inType && isReferenceIdentifier(parent, keyInParent)) {
+        const start = current.loc?.start;
+        if (current.name && start)
+            references.push({ name: current.name, line: start.line, column: start.column });
+    }
+    const opensType = inType || (current.type.startsWith('TS') && !tsValueNodes.has(current.type));
+    for (const childKey of Object.keys(current)) {
+        if (astSkipKeys.has(childKey))
+            continue;
+        const child = current[childKey];
+        const childOpensType = typeof child === 'object' && child !== null && typeof child.type === 'string' && child.type.startsWith('TS') && !tsValueNodes.has(child.type);
+        const childInType = opensType || astTypeKeys.has(childKey) || childOpensType;
+        walkAstNode(child, current, childKey, childInType, declared, references);
+    }
+};
+/**
+ * Pass ngữ nghĩa: báo biến CHƯA KHAI BÁO. Tự duyệt AST (object thuần) — KHÔNG dùng `@babel/traverse`
+ * (cần `process` của Node → crash browser). Hợp lệ = binding trong code + global JS/DOM + `completionLabels`.
+ */
+export const collectUndeclaredIdentifiers = async (ast, doc, completionLabels, taintedLines = new Set()) => {
+    const globalsSet = await getKnownGlobals();
+    const declared = new Set();
+    const references = [];
+    walkAstNode(ast, null, '', false, declared, references);
+    const diagnostics = [];
+    const seen = new Set();
+    for (const reference of references) {
+        const { name, line: startLine, column: startColumn } = reference;
+        if (declared.has(name) || globalsSet.has(name) || completionLabels.has(name))
+            continue;
+        if (taintedLines.has(startLine))
+            continue;
+        const dedupeKey = `${startLine}:${startColumn}:${name}`;
+        if (seen.has(dedupeKey))
+            continue;
+        seen.add(dedupeKey);
+        const line = doc.line(Math.min(Math.max(startLine, 1), doc.lines));
+        const from = Math.min(line.from + Math.max(startColumn, 0), doc.length);
+        const to = Math.min(from + name.length, doc.length);
+        diagnostics.push({ from, to: Math.max(from + 1, to), severity: 'error', message: `"${name}" is not defined` });
+    }
+    return diagnostics;
+};
+/**
+ * Toàn bộ pipeline validate JS/TS:
+ * - Pass 1: trailing dot (text) — flag đúng vị trí dấu `.` cuối dòng + đánh dấu dòng tainted.
+ * - Pass 2: lỗi cú pháp babel — bỏ lỗi trên dòng tainted (cascading).
+ * - Pass 3: rule cần AST (thiếu `;`, biến chưa khai báo). Trailing dot được "vá" (`.`→space) để babel
+ *   vẫn parse được phần còn lại → rule vẫn chạy cho các dòng KHÁC.
+ */
+export const computeJsDiagnostics = async (doc, code, completionLabels) => {
+    const diagnostics = [];
+    if (code.trim() === '') {
+        return diagnostics;
+    }
+    const taintedLines = new Set();
+    const dotPositions = [];
+    collectTrailingDotDiagnostics(doc, diagnostics, taintedLines, dotPositions);
+    const parseCode = replaceCharsWithSpace(code, dotPositions);
+    const parser = await getBabelParser();
+    const { errors, ast } = parseJs(parser, parseCode);
+    const seen = new Set();
+    for (const error of errors) {
+        const location = error.loc;
+        if (!location)
+            continue;
+        const lineNumber = Math.min(Math.max(location.line, 1), doc.lines);
+        if (taintedLines.has(lineNumber))
+            continue;
+        const line = doc.line(lineNumber);
+        const errorPos = Math.min(line.from + Math.max(location.column, 0), doc.length);
+        const to = Math.min(errorPos + 1, doc.length);
+        const from = errorPos >= to && errorPos > 0 ? errorPos - 1 : errorPos;
+        const message = buildJsErrorMessage(doc, errorPos, error.message);
+        const dedupeKey = `${from}:${message}`;
+        if (seen.has(dedupeKey))
+            continue;
+        seen.add(dedupeKey);
+        diagnostics.push({ from, to: Math.max(from + 1, to), severity: 'error', message });
+    }
+    if (errors.length === 0 && ast) {
+        collectMissingSemicolonDiagnostics(ast, code, diagnostics, taintedLines);
+        diagnostics.push(...(await collectUndeclaredIdentifiers(ast, doc, completionLabels, taintedLines)));
+    }
+    return diagnostics;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"js-linter.js","sourceRoot":"","sources":["../../../../../../libs-ui/components/preview-text-data/src/linters/js-linter.ts"],"names":[],"mappings":"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","sourcesContent":["import { Diagnostic } from '@codemirror/lint';\nimport { Text } from '@codemirror/state';\nimport { get } from '@libs-ui/utils';\nimport { astSkipKeys, astTypeKeys, tsValueNodes } from '../preview-text-data.define';\nimport { T_AstNode } from '../preview-text-data.type';\nimport { getTokenBefore } from './linter-shared';\n\ntype T_BabelError = { loc?: { line: number; column: number }; message: string };\ntype T_AstReference = { name: string; line: number; column: number };\n\n// Cache module-level (chia sẻ giữa các instance editor) — đều immutable, lazy-load 1 lần.\nlet babelParserModule: typeof import('@babel/parser') | undefined;\nlet knownGlobalsSet: Set<string> | undefined;\n\n/** Lazy-load + cache module @babel/parser (chỉ tải lần đầu khi lint JS/TS). */\nconst getBabelParser = async (): Promise<typeof import('@babel/parser')> => {\n  if (!babelParserModule) {\n    babelParserModule = await import('@babel/parser');\n  }\n  return babelParserModule;\n};\n\n/** Lazy-load + cache tập biến toàn cục JS/DOM hợp lệ từ package `globals` (JSON thuần, browser-safe). */\nconst getKnownGlobals = async (): Promise<Set<string>> => {\n  if (!knownGlobalsSet) {\n    const globalsModule = (await import('globals')) as unknown as { default?: Record<string, Record<string, boolean>> };\n    const globalsData = (globalsModule.default ?? globalsModule) as Record<string, Record<string, boolean>>;\n    knownGlobalsSet = new Set<string>([...Object.keys(globalsData['builtin'] ?? {}), ...Object.keys(globalsData['browser'] ?? {}), ...Object.keys(globalsData['es2021'] ?? {})]);\n  }\n  return knownGlobalsSet;\n};\n\n/**\n * Parse code, trả về vừa danh sách lỗi cú pháp vừa AST (nếu parse sạch).\n * `errorRecovery` gom nhiều lỗi vào `result.errors`; lỗi nặng vẫn `throw` → bắt thêm ở catch.\n */\nexport const parseJs = (parser: typeof import('@babel/parser'), code: string): { errors: T_BabelError[]; ast?: object } => {\n  try {\n    const result = parser.parse(code, {\n      sourceType: 'module',\n      errorRecovery: true,\n      plugins: ['typescript', 'jsx'],\n      allowReturnOutsideFunction: true,\n      allowAwaitOutsideFunction: true,\n      allowImportExportEverywhere: true,\n      allowSuperOutsideMethod: true,\n      allowNewTargetOutsideFunction: true,\n      allowUndeclaredExports: true,\n    });\n    return { errors: result.errors as T_BabelError[], ast: result };\n  } catch (error: unknown) {\n    const loc = get(error, 'loc') as { line: number; column: number } | undefined;\n    const message = (get(error, 'message') as string) || 'JavaScript syntax error';\n    return { errors: [{ loc, message }] };\n  }\n};\n\n/** Giữ cho test/back-compat: chỉ lấy danh sách lỗi cú pháp. */\nexport const collectBabelErrors = (parser: typeof import('@babel/parser'), code: string): T_BabelError[] => parseJs(parser, code).errors;\n\n/**\n * Quét text từng dòng, flag dấu \".\" cuối dòng (incomplete property access) tại ĐÚNG vị trí dấu chấm.\n * Thu thập `taintedLines` (dòng có trailing dot) + `dotPositions` (offset dấu chấm để vá khi parse).\n */\nexport const collectTrailingDotDiagnostics = (doc: Text, diagnostics: Diagnostic[], taintedLines: Set<number>, dotPositions: number[]): void => {\n  for (let lineNumber = 1; lineNumber <= doc.lines; lineNumber++) {\n    const line = doc.line(lineNumber);\n    const trimmed = line.text.trimEnd();\n    const match = /(\\w+)\\.\\s*$/.exec(trimmed);\n    if (!match) {\n      continue;\n    }\n    taintedLines.add(lineNumber);\n    const dotPosition = line.from + trimmed.lastIndexOf('.');\n    dotPositions.push(dotPosition);\n    diagnostics.push({ from: dotPosition, to: dotPosition + 1, severity: 'error', message: `Incomplete property access on \"${match[1]}\"` });\n  }\n};\n\n/** Thay các ký tự tại `positions` bằng space, giữ nguyên độ dài chuỗi (để offset không đổi). */\nconst replaceCharsWithSpace = (code: string, positions: number[]): string => {\n  if (!positions.length) {\n    return code;\n  }\n  const chars = code.split('');\n  for (const position of positions) {\n    if (position >= 0 && position < chars.length) {\n      chars[position] = ' ';\n    }\n  }\n  return chars.join('');\n};\n\n/** VariableDeclaration ở `for(let i=0;...)` / `for..in` / `for..of` KHÔNG cần `;` cuối. */\nconst requiresSemicolon = (nodeType: string, parentType: string, keyInParent: string): boolean => {\n  if (nodeType === 'VariableDeclaration') {\n    if (parentType === 'ForStatement' && keyInParent === 'init') return false;\n    if ((parentType === 'ForInStatement' || parentType === 'ForOfStatement') && keyInParent === 'left') return false;\n  }\n  return true;\n};\n\n/**\n * Rule custom \"require semicolon\": câu lệnh (const/let/return/expression...) không kết thúc bằng `;` → báo lỗi.\n * Dùng vị trí `node.end` của AST babel; bỏ qua dòng tainted (trailing dot) để không chồng lỗi.\n */\nexport const collectMissingSemicolonDiagnostics = (ast: object, code: string, diagnostics: Diagnostic[], taintedLines: Set<number>): void => {\n  const semiNodes = new Set(['ExpressionStatement', 'VariableDeclaration', 'ReturnStatement', 'ThrowStatement', 'BreakStatement', 'ContinueStatement', 'DoWhileStatement', 'DebuggerStatement']);\n  const seen = new Set<number>();\n  const lineOf = (offset: number) => code.slice(0, offset).split('\\n').length;\n  const walk = (node: unknown, parentType: string, keyInParent: string): void => {\n    if (Array.isArray(node)) {\n      for (const item of node) walk(item, parentType, keyInParent);\n      return;\n    }\n    if (!node || typeof node !== 'object') return;\n    const current = node as T_AstNode;\n    if (typeof current.type !== 'string') return;\n\n    if (semiNodes.has(current.type) && requiresSemicolon(current.type, parentType, keyInParent) && typeof current.end === 'number') {\n      const end = Math.min(current.end, code.length);\n      if (end > 0 && code.charAt(end - 1) !== ';' && !seen.has(end) && !taintedLines.has(lineOf(end - 1))) {\n        seen.add(end);\n        diagnostics.push({ from: end - 1, to: end, severity: 'error', message: 'Missing semicolon' });\n      }\n    }\n\n    for (const childKey of Object.keys(current)) {\n      if (astSkipKeys.has(childKey)) continue;\n      walk(current[childKey], current.type, childKey);\n    }\n  };\n  walk((ast as { program?: unknown }).program ?? ast, '', '');\n};\n\n/** Chuẩn hóa message: thân thiện cho trailing dot + heuristic kiểu cũ cho \"Unexpected token\"; bỏ hậu tố \"(line:col)\". */\nexport const buildJsErrorMessage = (doc: Text, from: number, rawMessage: string): string => {\n  const charBefore = from > 0 ? doc.sliceString(from - 1, from) : '';\n  if (charBefore === '.') {\n    const owner = getTokenBefore(doc, from).replace(/\\.$/, '');\n    return owner ? `Incomplete property access on \"${owner}\"` : 'Incomplete property access';\n  }\n\n  const cleaned = rawMessage.replace(/\\s*\\(\\d+:\\d+\\)\\s*$/, '').trim();\n  if (/missing semicolon/i.test(cleaned)) {\n    return 'Unexpected token — missing operator or separator between expressions';\n  }\n  if (/^unexpected token$/i.test(cleaned)) {\n    const prevToken = getTokenBefore(doc, from);\n    if (prevToken.endsWith('(')) return 'Missing closing \")\"';\n    if (prevToken.endsWith('[')) return 'Missing closing \"]\"';\n    if (/^function$/i.test(prevToken)) return 'Expected function name or \"(\"';\n    if (/^return$/i.test(prevToken)) return 'Invalid expression after \"return\"';\n    if (/^=>$/.test(prevToken)) return 'Expected function body after \"=>\"';\n    if (/^const$|^let$|^var$/i.test(prevToken)) return 'Expected variable name';\n  }\n  return `JavaScript syntax error: ${cleaned}`;\n};\n\n/** Lấy tên binding từ pattern (Identifier, destructuring object/array, default, rest). */\nconst collectPatternNames = (node: T_AstNode | null | undefined, declared: Set<string>): void => {\n  if (!node || typeof node.type !== 'string') return;\n  switch (node.type) {\n    case 'Identifier':\n      if (node.name) declared.add(node.name);\n      return;\n    case 'ObjectPattern':\n      if (node.properties) for (const property of node.properties) collectPatternNames(property.type === 'RestElement' ? property.argument : property.value, declared);\n      return;\n    case 'ArrayPattern':\n      if (node.elements) for (const element of node.elements) collectPatternNames(element, declared);\n      return;\n    case 'AssignmentPattern':\n      collectPatternNames(node.left, declared);\n      return;\n    case 'RestElement':\n      collectPatternNames(node.argument, declared);\n      return;\n    case 'TSParameterProperty':\n      collectPatternNames(node.parameter, declared);\n      return;\n    default:\n      return;\n  }\n};\n\n/** Thu thập tên binding (biến/hàm/class/param/import/enum...) từ 1 node vào tập `declared`. */\nconst collectBindingNames = (node: T_AstNode, declared: Set<string>): void => {\n  switch (node.type) {\n    case 'VariableDeclarator':\n      collectPatternNames(node.id, declared);\n      return;\n    case 'FunctionDeclaration':\n    case 'FunctionExpression':\n    case 'ClassDeclaration':\n    case 'ClassExpression':\n      if (node.id?.name) declared.add(node.id.name);\n      if (node.params) for (const param of node.params) collectPatternNames(param, declared);\n      return;\n    case 'ArrowFunctionExpression':\n      if (node.params) for (const param of node.params) collectPatternNames(param, declared);\n      return;\n    case 'CatchClause':\n      collectPatternNames(node.param, declared);\n      return;\n    case 'ImportDefaultSpecifier':\n    case 'ImportNamespaceSpecifier':\n    case 'ImportSpecifier':\n      if (node.local?.name) declared.add(node.local.name);\n      return;\n    case 'TSEnumDeclaration':\n    case 'TSModuleDeclaration':\n      if (node.id?.name) declared.add(node.id.name);\n      return;\n    default:\n      return;\n  }\n};\n\n/** Xác định 1 Identifier có phải tham chiếu giá trị không (loại property access, key object, declaration id, label...). */\nconst isReferenceIdentifier = (parent: T_AstNode | null, keyInParent: string): boolean => {\n  if (!parent) return true;\n  const parentType = parent.type;\n  if ((parentType === 'MemberExpression' || parentType === 'OptionalMemberExpression') && keyInParent === 'property' && !parent.computed) return false;\n  if ((parentType === 'ObjectProperty' || parentType === 'ObjectMethod' || parentType === 'ClassMethod' || parentType === 'ClassProperty' || parentType === 'ClassPrivateProperty' || parentType === 'PropertyDefinition') && keyInParent === 'key' && !parent.computed) return false;\n  if (keyInParent === 'label') return false;\n  if (parentType === 'TSQualifiedName' && keyInParent === 'right') return false;\n  if (parentType === 'VariableDeclarator' && keyInParent === 'id') return false;\n  if ((parentType === 'FunctionDeclaration' || parentType === 'FunctionExpression' || parentType === 'ClassDeclaration' || parentType === 'ClassExpression') && keyInParent === 'id') return false;\n  if (parentType === 'ImportSpecifier' || parentType === 'ImportDefaultSpecifier' || parentType === 'ImportNamespaceSpecifier' || parentType === 'ExportSpecifier') return false;\n  if (parentType === 'MetaProperty') return false;\n  if (parentType === 'TSEnumMember' && keyInParent === 'id') return false;\n  return true;\n};\n\n/** Duyệt đệ quy AST: gom binding name vào `declared`, gom identifier tham chiếu vào `references`. */\nconst walkAstNode = (node: unknown, parent: T_AstNode | null, keyInParent: string, inType: boolean, declared: Set<string>, references: T_AstReference[]): void => {\n  if (Array.isArray(node)) {\n    for (const item of node) walkAstNode(item, parent, keyInParent, inType, declared, references);\n    return;\n  }\n  if (!node || typeof node !== 'object') return;\n  const current = node as T_AstNode;\n  if (typeof current.type !== 'string') return;\n\n  collectBindingNames(current, declared);\n\n  if (current.type === 'Identifier' && !inType && isReferenceIdentifier(parent, keyInParent)) {\n    const start = current.loc?.start;\n    if (current.name && start) references.push({ name: current.name, line: start.line, column: start.column });\n  }\n\n  const opensType = inType || (current.type.startsWith('TS') && !tsValueNodes.has(current.type));\n  for (const childKey of Object.keys(current)) {\n    if (astSkipKeys.has(childKey)) continue;\n    const child = current[childKey];\n    const childOpensType = typeof child === 'object' && child !== null && typeof (child as T_AstNode).type === 'string' && (child as T_AstNode).type.startsWith('TS') && !tsValueNodes.has((child as T_AstNode).type);\n    const childInType = opensType || astTypeKeys.has(childKey) || childOpensType;\n    walkAstNode(child, current, childKey, childInType, declared, references);\n  }\n};\n\n/**\n * Pass ngữ nghĩa: báo biến CHƯA KHAI BÁO. Tự duyệt AST (object thuần) — KHÔNG dùng `@babel/traverse`\n * (cần `process` của Node → crash browser). Hợp lệ = binding trong code + global JS/DOM + `completionLabels`.\n */\nexport const collectUndeclaredIdentifiers = async (ast: object, doc: Text, completionLabels: Set<string>, taintedLines: Set<number> = new Set()): Promise<Diagnostic[]> => {\n  const globalsSet = await getKnownGlobals();\n  const declared = new Set<string>();\n  const references: T_AstReference[] = [];\n\n  walkAstNode(ast as T_AstNode, null, '', false, declared, references);\n\n  const diagnostics: Diagnostic[] = [];\n  const seen = new Set<string>();\n  for (const reference of references) {\n    const { name, line: startLine, column: startColumn } = reference;\n    if (declared.has(name) || globalsSet.has(name) || completionLabels.has(name)) continue;\n    if (taintedLines.has(startLine)) continue;\n\n    const dedupeKey = `${startLine}:${startColumn}:${name}`;\n    if (seen.has(dedupeKey)) continue;\n    seen.add(dedupeKey);\n\n    const line = doc.line(Math.min(Math.max(startLine, 1), doc.lines));\n    const from = Math.min(line.from + Math.max(startColumn, 0), doc.length);\n    const to = Math.min(from + name.length, doc.length);\n    diagnostics.push({ from, to: Math.max(from + 1, to), severity: 'error', message: `\"${name}\" is not defined` });\n  }\n  return diagnostics;\n};\n\n/**\n * Toàn bộ pipeline validate JS/TS:\n * - Pass 1: trailing dot (text) — flag đúng vị trí dấu `.` cuối dòng + đánh dấu dòng tainted.\n * - Pass 2: lỗi cú pháp babel — bỏ lỗi trên dòng tainted (cascading).\n * - Pass 3: rule cần AST (thiếu `;`, biến chưa khai báo). Trailing dot được \"vá\" (`.`→space) để babel\n *   vẫn parse được phần còn lại → rule vẫn chạy cho các dòng KHÁC.\n */\nexport const computeJsDiagnostics = async (doc: Text, code: string, completionLabels: Set<string>): Promise<Diagnostic[]> => {\n  const diagnostics: Diagnostic[] = [];\n  if (code.trim() === '') {\n    return diagnostics;\n  }\n\n  const taintedLines = new Set<number>();\n  const dotPositions: number[] = [];\n  collectTrailingDotDiagnostics(doc, diagnostics, taintedLines, dotPositions);\n\n  const parseCode = replaceCharsWithSpace(code, dotPositions);\n  const parser = await getBabelParser();\n  const { errors, ast } = parseJs(parser, parseCode);\n  const seen = new Set<string>();\n  for (const error of errors) {\n    const location = error.loc;\n    if (!location) continue;\n    const lineNumber = Math.min(Math.max(location.line, 1), doc.lines);\n    if (taintedLines.has(lineNumber)) continue;\n    const line = doc.line(lineNumber);\n    const errorPos = Math.min(line.from + Math.max(location.column, 0), doc.length);\n    const to = Math.min(errorPos + 1, doc.length);\n    const from = errorPos >= to && errorPos > 0 ? errorPos - 1 : errorPos;\n    const message = buildJsErrorMessage(doc, errorPos, error.message);\n    const dedupeKey = `${from}:${message}`;\n    if (seen.has(dedupeKey)) continue;\n    seen.add(dedupeKey);\n    diagnostics.push({ from, to: Math.max(from + 1, to), severity: 'error', message });\n  }\n\n  if (errors.length === 0 && ast) {\n    collectMissingSemicolonDiagnostics(ast, code, diagnostics, taintedLines);\n    diagnostics.push(...(await collectUndeclaredIdentifiers(ast, doc, completionLabels, taintedLines)));\n  }\n\n  return diagnostics;\n};\n"]}

package/esm2022/linters/json-linter.mjs

@@ -0,0 +1,14 @@
+import { get } from '@libs-ui/utils';
+/** Validate JSON bằng `JSON.parse`. Lỗi → 1 diagnostic phủ toàn bộ nội dung. */
+export const computeJsonDiagnostics = (view) => {
+    const text = view.state.doc.toString();
+    const diagnostics = [];
+    try {
+        JSON.parse(text);
+    }
+    catch (error) {
+        diagnostics.push({ from: 0, to: text.length, severity: 'error', message: get(error, 'message', '') });
+    }
+    return diagnostics;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoianNvbi1saW50ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzLXVpL2NvbXBvbmVudHMvcHJldmlldy10ZXh0LWRhdGEvc3JjL2xpbnRlcnMvanNvbi1saW50ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBRXJDLGdGQUFnRjtBQUNoRixNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRyxDQUFDLElBQWdCLEVBQWdCLEVBQUU7SUFDdkUsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDdkMsTUFBTSxXQUFXLEdBQWlCLEVBQUUsQ0FBQztJQUNyQyxJQUFJLENBQUM7UUFDSCxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ25CLENBQUM7SUFBQyxPQUFPLEtBQWMsRUFBRSxDQUFDO1FBQ3hCLFdBQVcsQ0FBQyxJQUFJLENBQUMsRUFBRSxJQUFJLEVBQUUsQ0FBQyxFQUFFLEVBQUUsRUFBRSxJQUFJLENBQUMsTUFBTSxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLEdBQUcsQ0FBQyxLQUFLLEVBQUUsU0FBUyxFQUFFLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUN4RyxDQUFDO0lBQ0QsT0FBTyxXQUFXLENBQUM7QUFDckIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlhZ25vc3RpYyB9IGZyb20gJ0Bjb2RlbWlycm9yL2xpbnQnO1xuaW1wb3J0IHsgRWRpdG9yVmlldyB9IGZyb20gJ0Bjb2RlbWlycm9yL3ZpZXcnO1xuaW1wb3J0IHsgZ2V0IH0gZnJvbSAnQGxpYnMtdWkvdXRpbHMnO1xuXG4vKiogVmFsaWRhdGUgSlNPTiBi4bqxbmcgYEpTT04ucGFyc2VgLiBM4buXaSDihpIgMSBkaWFnbm9zdGljIHBo4bunIHRvw6BuIGLhu5kgbuG7mWkgZHVuZy4gKi9cbmV4cG9ydCBjb25zdCBjb21wdXRlSnNvbkRpYWdub3N0aWNzID0gKHZpZXc6IEVkaXRvclZpZXcpOiBEaWFnbm9zdGljW10gPT4ge1xuICBjb25zdCB0ZXh0ID0gdmlldy5zdGF0ZS5kb2MudG9TdHJpbmcoKTtcbiAgY29uc3QgZGlhZ25vc3RpY3M6IERpYWdub3N0aWNbXSA9IFtdO1xuICB0cnkge1xuICAgIEpTT04ucGFyc2UodGV4dCk7XG4gIH0gY2F0Y2ggKGVycm9yOiB1bmtub3duKSB7XG4gICAgZGlhZ25vc3RpY3MucHVzaCh7IGZyb206IDAsIHRvOiB0ZXh0Lmxlbmd0aCwgc2V2ZXJpdHk6ICdlcnJvcicsIG1lc3NhZ2U6IGdldChlcnJvciwgJ21lc3NhZ2UnLCAnJykgfSk7XG4gIH1cbiAgcmV0dXJuIGRpYWdub3N0aWNzO1xufTtcbiJdfQ==

package/esm2022/linters/linter-shared.mjs

@@ -0,0 +1,8 @@
+/** Lấy token (chuỗi không khoảng trắng) liền trước vị trí `pos` trong document. Dùng chung cho JS/SQL/Python. */
+export const getTokenBefore = (doc, pos) => {
+    const start = Math.max(0, pos - 30);
+    const text = doc.sliceString(start, pos);
+    const match = /(\S+)\s*$/.exec(text);
+    return match?.[1] ?? '';
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGludGVyLXNoYXJlZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMtdWkvY29tcG9uZW50cy9wcmV2aWV3LXRleHQtZGF0YS9zcmMvbGludGVycy9saW50ZXItc2hhcmVkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLGlIQUFpSDtBQUNqSCxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsQ0FBQyxHQUFTLEVBQUUsR0FBVyxFQUFVLEVBQUU7SUFDL0QsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUUsR0FBRyxHQUFHLEVBQUUsQ0FBQyxDQUFDO0lBQ3BDLE1BQU0sSUFBSSxHQUFHLEdBQUcsQ0FBQyxXQUFXLENBQUMsS0FBSyxFQUFFLEdBQUcsQ0FBQyxDQUFDO0lBQ3pDLE1BQU0sS0FBSyxHQUFHLFdBQVcsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDckMsT0FBTyxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFLENBQUM7QUFDMUIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVGV4dCB9IGZyb20gJ0Bjb2RlbWlycm9yL3N0YXRlJztcblxuLyoqIEzhuqV5IHRva2VuIChjaHXhu5dpIGtow7RuZyBraG/huqNuZyB0cuG6r25nKSBsaeG7gW4gdHLGsOG7m2MgduG7iyB0csOtIGBwb3NgIHRyb25nIGRvY3VtZW50LiBEw7luZyBjaHVuZyBjaG8gSlMvU1FML1B5dGhvbi4gKi9cbmV4cG9ydCBjb25zdCBnZXRUb2tlbkJlZm9yZSA9IChkb2M6IFRleHQsIHBvczogbnVtYmVyKTogc3RyaW5nID0+IHtcbiAgY29uc3Qgc3RhcnQgPSBNYXRoLm1heCgwLCBwb3MgLSAzMCk7XG4gIGNvbnN0IHRleHQgPSBkb2Muc2xpY2VTdHJpbmcoc3RhcnQsIHBvcyk7XG4gIGNvbnN0IG1hdGNoID0gLyhcXFMrKVxccyokLy5leGVjKHRleHQpO1xuICByZXR1cm4gbWF0Y2g/LlsxXSA/PyAnJztcbn07XG4iXX0=

package/esm2022/linters/python-linter.mjs

@@ -0,0 +1,52 @@
+import { syntaxTree } from '@codemirror/language';
+import { getTokenBefore } from './linter-shared';
+const buildPythonErrorMessage = (doc, node) => {
+    if (node.from !== node.to) {
+        const text = doc.sliceString(node.from, node.to).trim();
+        return `Python syntax error${text ? ` near "${text}"` : ''}`;
+    }
+    const prevToken = getTokenBefore(doc, node.from);
+    if (!prevToken)
+        return 'Python syntax error';
+    if (/^def$/i.test(prevToken))
+        return 'Expected function name after "def"';
+    if (/^class$/i.test(prevToken))
+        return 'Expected class name after "class"';
+    if (/^return$/i.test(prevToken))
+        return 'Invalid expression after "return"';
+    if (/^import$/i.test(prevToken))
+        return 'Expected module name after "import"';
+    if (/^from$/i.test(prevToken))
+        return 'Expected module name after "from"';
+    if (/^if$/i.test(prevToken))
+        return 'Expected condition after "if"';
+    if (/^elif$/i.test(prevToken))
+        return 'Expected condition after "elif"';
+    if (/^while$/i.test(prevToken))
+        return 'Expected condition after "while"';
+    if (/^for$/i.test(prevToken))
+        return 'Expected variable after "for"';
+    if (prevToken.endsWith('.'))
+        return `Incomplete attribute access on "${prevToken.slice(0, -1)}"`;
+    if (prevToken.endsWith('('))
+        return 'Missing closing ")"';
+    if (prevToken.endsWith('['))
+        return 'Missing closing "]"';
+    return `Python syntax error near "${prevToken}"`;
+};
+/** Phát hiện lỗi cú pháp Python từ error node của syntaxTree (Lezer) — cùng approach SQL. */
+export const computePythonDiagnostics = (view) => {
+    const diagnostics = [];
+    const doc = view.state.doc;
+    syntaxTree(view.state).iterate({
+        enter: (node) => {
+            if (!node.type.isError)
+                return;
+            const from = Math.max(0, node.from - 1);
+            const to = node.from === node.to ? node.from + 1 : node.to;
+            diagnostics.push({ from, to: Math.min(to, doc.length), severity: 'error', message: buildPythonErrorMessage(doc, node) });
+        },
+    });
+    return diagnostics;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/linters/sql-linter.mjs

@@ -0,0 +1,34 @@
+import { syntaxTree } from '@codemirror/language';
+import { getTokenBefore } from './linter-shared';
+const buildSqlErrorMessage = (doc, node) => {
+    if (node.from !== node.to) {
+        const text = doc.sliceString(node.from, node.to);
+        return `SQL syntax error near "${text}"`;
+    }
+    const prevToken = getTokenBefore(doc, node.from);
+    if (!prevToken)
+        return 'SQL syntax error at beginning of statement';
+    if (/FROM$/i.test(prevToken))
+        return 'Expected table name after FROM';
+    if (/SELECT$/i.test(prevToken))
+        return 'Expected column list after SELECT';
+    if (/WHERE$/i.test(prevToken))
+        return 'Expected condition after WHERE';
+    if (prevToken.endsWith('('))
+        return 'Missing closing ")"';
+    return `Unexpected end of SQL after "${prevToken}"`;
+};
+/** Phát hiện lỗi cú pháp SQL từ error node của syntaxTree (Lezer). */
+export const computeSqlDiagnostics = (view) => {
+    const diagnostics = [];
+    const doc = view.state.doc;
+    syntaxTree(view.state).iterate({
+        enter: (node) => {
+            if (!node.type.isError)
+                return;
+            diagnostics.push({ from: Math.max(0, node.from - 1), to: node.from, severity: 'error', message: buildSqlErrorMessage(doc, node) });
+        },
+    });
+    return diagnostics;
+};
+//# sourceMappingURL=data:application/json;base64,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