@round-core/lint 0.1.0

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@round-core/lint",
+  "version": "0.1.0",
+  "description": "ESLint processor for RoundJS files",
+  "type": "module",
+  "main": "src/index.js",
+  "files": [
+    "src"
+  ],
+  "peerDependencies": {
+    "eslint": "^8.0.0 || ^9.0.0"
+  },
+  "dependencies": {
+    "@round-core/shared": "latest"
+  }
+}

package/src/index.js

@@ -0,0 +1,7 @@
+import processor from './processor.js';
+
+export default {
+  processors: {
+    '.round': processor
+  }
+};

package/src/offset-map.js

@@ -0,0 +1,85 @@
+/**
+ * Computes line start offsets for a given source string.
+ * @param {string} source
+ * @returns {number[]} Array of offsets where each line starts.
+ */
+function computeLineStarts(source) {
+  const lineStarts = [0];
+  for (let i = 0; i < source.length; i++) {
+    if (source[i] === '\n') {
+      lineStarts.push(i + 1);
+    }
+  }
+  return lineStarts;
+}
+
+/**
+ * Converts a 0-based offset to line and column (1-based).
+ * @param {number} offset
+ * @param {number[]} lineStarts
+ * @returns {{line: number, column: number}}
+ */
+function offsetToPos(offset, lineStarts) {
+  let low = 0;
+  let high = lineStarts.length - 1;
+
+  while (low <= high) {
+    const mid = (low + high) >>> 1;
+    if (lineStarts[mid] <= offset) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+
+  const lineIndex = high; // 0-based
+  const lineStart = lineStarts[lineIndex];
+  
+  return {
+    line: lineIndex + 1,
+    column: offset - lineStart + 1
+  };
+}
+
+/**
+ * Remaps ESLint messages to original source positions.
+ * @param {any[]} messages
+ * @param {{source: string, mapper: any}} state
+ * @returns {any[]}
+ */
+export function remapMessages(messages, state) {
+  const { source, mapper } = state;
+  const lineStarts = computeLineStarts(source);
+
+  return messages.map(msg => {
+    if (!msg.range && !msg.line) return msg;
+
+    let startOffset, endOffset;
+    
+    if (msg.range) {
+        startOffset = msg.range[0];
+        endOffset = msg.range[1];
+    } else {
+       return msg;
+    }
+
+    // Remap offsets using SourceMapper
+    const originalStart = mapper.remap(startOffset);
+    const originalEnd = mapper.remap(endOffset);
+
+    // Calculate new line/column
+    const startPos = offsetToPos(originalStart, lineStarts);
+    const endPos = offsetToPos(originalEnd, lineStarts);
+
+    // Clone and update message
+    return {
+      ...msg,
+      line: startPos.line,
+      column: startPos.column,
+      endLine: endPos.line,
+      endColumn: endPos.column,
+      range: [originalStart, originalEnd],
+      fix: undefined
+    };
+  });
+}

package/src/processor.js

@@ -0,0 +1,65 @@
+import { SourceMapper, runPreprocess } from '@round-core/shared';
+import { fileState } from './state.js';
+import { remapMessages } from './offset-map.js';
+
+export default {
+  preprocess(code, filename) {
+    const mapper = new SourceMapper();
+    runPreprocess(code, mapper, 0);
+    
+    // MAGIC: Suppress false positives for RoundJS syntax without react-plugin
+    
+    // 1. Identify top-level names (imports and declarations)
+    const topLevelNames = new Set();
+    const declMatches = mapper.code.matchAll(/^\s*(?:export\s+)?(?:function|const|let|var|class|import)\s+({[\s\S]*?}|[a-zA-Z0-9_$]+)/gm);
+    for (const m of declMatches) {
+        const inner = m[1];
+        if (inner.startsWith('{')) {
+            const innerNames = inner.match(/([a-zA-Z0-9_$]+)/g);
+            if (innerNames) innerNames.forEach(n => topLevelNames.add(n));
+        } else {
+            topLevelNames.add(inner);
+        }
+    }
+
+    // 2. Mark components used in JSX as "used"
+    const cleanForComponents = mapper.code.replace(/`[\s\S]*?`/g, '');
+    const componentMatches = cleanForComponents.matchAll(/<([A-Z][a-zA-Z0-9_$]*)/g);
+    const components = new Set([...componentMatches].map(m => m[1]));
+    
+    let magic = '\n\n/* eslint-disable */\n/* globals RoundControlFlow, e, item */\n;';
+    
+    // Usage for top-level components only
+    for (const comp of components) {
+        if (topLevelNames.has(comp)) {
+            magic += `${comp};`; 
+        }
+    }
+    
+    mapper.add(magic, code.length);
+
+    fileState.set(filename, {
+      source: code,
+      mapper: mapper
+    });
+
+    return [mapper.code];
+  },
+
+  postprocess(messages, filename) {
+    const state = fileState.get(filename);
+    
+    // Clean up state (optional, but good for memory if ESLint is long running)
+    // However, ESLint might run multiple fixes? 
+    // For now we keep it simple. If we delete here, we might lose it if 
+    // specific flows access it again. But usually postprocess is the end.
+    fileState.delete(filename);
+
+    if (!state) return messages[0];
+
+    // Remap messages from the first (and only) part
+    return remapMessages(messages[0], state);
+  },
+
+  supportsAutofix: false
+};

package/src/state.js

@@ -0,0 +1,14 @@
+
+const map = new Map();
+
+export const fileState = {
+  set(file, state) {
+    map.set(file, state);
+  },
+  get(file) {
+    return map.get(file);
+  },
+  delete(file) {
+    map.delete(file);
+  }
+};