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

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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