@thethracian/oxlint-config 0.2.0 → 0.3.0

package/dist/rules/effect-rule-core.js

@@ -1,26 +1,20 @@
-import { readFileSync } from 'node:fs';
-import { stripComments, stripCommentsAndStrings } from './effect-source-helpers.js';
-function readSource(context) {
-    if (context.sourceCode?.text !== undefined) {
-        return context.sourceCode.text;
-    }
-    if (context.sourceCode?.getText) {
-        return context.sourceCode.getText();
-    }
-    if (!context.filename) {
-        return '';
-    }
-    try {
-        return readFileSync(context.filename, 'utf-8');
-    }
-    catch {
-        return '';
-    }
-}
-function isCodeAt(strippedSource, index) {
-    return strippedSource[index]?.trim() !== '';
-}
-function hasPattern(source, patterns) {
+/* -------------------------------------------------------------------------- */
+/*      Core runtime for source-backed and AST-backed Effect lint rules.      */
+/* -------------------------------------------------------------------------- */
+import { canonicalizeEffectAPIAliases } from './effect-rule-aliases.js';
+import { effectDiagnosticMessage } from './diagnostic-guidance.js';
+import { readCachedSource } from './source-cache.js';
+import { stripCommentsAndStrings } from './effect-source-helpers.js';
+const LINE_START_CACHE_MAX = 256;
+const TOKEN_GATE_CACHE_MAX = 512;
+const CHAR_CODE_NEWLINE = 10;
+const lineStartCache = new Map();
+const globalPatternCache = new WeakMap();
+const tokenGateCache = new WeakMap();
+const sourceTokenPresenceCache = new Map();
+const readSource = (context) => readCachedSource(context);
+const isCodeAt = (strippedSource, index) => strippedSource[index]?.trim() !== '';
+const hasPattern = (source, patterns) => {
     let strippedSource = undefined;
     return patterns.some((pattern) => {
         for (const match of source.matchAll(toGlobalRegExp(pattern))) {
@@ -31,60 +25,113 @@ function hasPattern(source, patterns) {
         }
         return false;
     });
-}
-function toGlobalRegExp(pattern) {
-    return new RegExp(pattern.source, pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`);
-}
-function locFromIndex(source, index) {
-    let line = 1;
-    let lineStart = 0;
-    for (let position = 0; position < index; position++) {
-        if (source.charCodeAt(position) === 10) {
-            line++;
-            lineStart = position + 1;
+};
+const toGlobalRegExp = (pattern) => {
+    const cachedPattern = globalPatternCache.get(pattern);
+    if (cachedPattern !== undefined) {
+        return cachedPattern;
+    }
+    let { flags } = pattern;
+    if (!flags.includes('g')) {
+        flags = `${flags}g`;
+    }
+    const globalPattern = new RegExp(pattern.source, flags);
+    globalPatternCache.set(pattern, globalPattern);
+    return globalPattern;
+};
+const cachedLineStarts = (source) => lineStartCache.get(source);
+const evictFirstLineStart = () => {
+    if (lineStartCache.size < LINE_START_CACHE_MAX) {
+        return;
+    }
+    const firstKey = lineStartCache.keys().next().value;
+    if (firstKey !== undefined) {
+        lineStartCache.delete(firstKey);
+    }
+};
+const computeLineStarts = (source) => {
+    const starts = [0];
+    for (let position = 0; position < source.length; position++) {
+        if (source.charCodeAt(position) === CHAR_CODE_NEWLINE) {
+            starts.push(position + 1);
         }
     }
+    return starts;
+};
+const lineStartsFor = (source) => {
+    const cachedStarts = cachedLineStarts(source);
+    if (cachedStarts !== undefined) {
+        return cachedStarts;
+    }
+    const starts = computeLineStarts(source);
+    evictFirstLineStart();
+    lineStartCache.set(source, starts);
+    return starts;
+};
+const lineIndexFor = (starts, index) => {
+    let low = 0;
+    let high = starts.length - 1;
+    while (low <= high) {
+        const middle = (low + high) >> 1;
+        const lineStart = starts[middle] ?? 0;
+        if (lineStart <= index) {
+            low = middle + 1;
+        }
+        else {
+            high = middle - 1;
+        }
+    }
+    return Math.max(0, high);
+};
+const locFromIndex = (source, index) => {
+    const starts = lineStartsFor(source);
+    const lineIndex = lineIndexFor(starts, index);
+    const lineStart = starts[lineIndex] ?? 0;
+    const line = lineIndex + 1;
     return { column: index - lineStart, line };
-}
-function firstPatternLoc(source, patterns) {
+};
+const firstPatternLOC = (source, patterns) => {
     let strippedSource = undefined;
     for (const pattern of patterns) {
         for (const match of source.matchAll(toGlobalRegExp(pattern))) {
             strippedSource ??= stripCommentsAndStrings(source);
-            if (!isCodeAt(strippedSource, match.index)) {
-                continue;
+            if (isCodeAt(strippedSource, match.index)) {
+                return locFromIndex(source, match.index);
             }
-            return locFromIndex(source, match.index);
         }
     }
     return undefined;
-}
-function reportPatternMatches(input) {
+};
+const reportPatternMatches = (input) => {
     const { context, node, source, spec } = input;
+    const message = effectDiagnosticMessage(spec.name, spec.message);
     if (!spec.countPatterns) {
         context.report({
-            loc: firstPatternLoc(source, spec.patterns ?? []),
-            message: spec.message,
+            loc: firstPatternLOC(source, spec.patterns ?? []),
+            message,
             node,
         });
         return;
     }
+    reportCountedPatternMatches(input, message);
+};
+const reportCountedPatternMatches = (input, message) => {
+    const { context, node, source, spec } = input;
     let strippedSource = undefined;
-    for (const pattern of spec.countPatterns) {
+    for (const pattern of spec.countPatterns ?? []) {
         for (const match of source.matchAll(toGlobalRegExp(pattern))) {
             strippedSource ??= stripCommentsAndStrings(source);
-            if (!isCodeAt(strippedSource, match.index)) {
-                continue;
+            if (isCodeAt(strippedSource, match.index)) {
+                context.report({
+                    loc: locFromIndex(source, match.index),
+                    message,
+                    node,
+                });
             }
-            context.report({
-                loc: locFromIndex(source, match.index),
-                message: spec.message,
-                node,
-            });
         }
     }
-}
-function checkResultIndex(result) {
+};
+const checkResultIndex = (result) => {
     if (typeof result === 'number') {
         return result;
     }
@@ -92,271 +139,184 @@ function checkResultIndex(result) {
         return result.index;
     }
     return undefined;
-}
-function isCheckViolation(result) {
-    return typeof result === 'boolean' ? result : true;
-}
-function makeProgramRule(spec, options) {
-    return {
-        meta: {
-            schema: options.schema,
-            type: 'problem',
-        },
-        create(context) {
-            const source = readSource(context);
-            const astVisitors = spec.ast?.(context, source) ?? {};
-            return {
-                ...astVisitors,
-                Program(node) {
-                    if (source === '') {
-                        return;
-                    }
-                    if (spec.ast && Array.isArray(node.body)) {
-                        return;
-                    }
-                    const canonicalSource = canonicalizeEffectApiAliases(source);
-                    const checkResult = spec.check?.(canonicalSource, context);
-                    if (checkResult !== undefined) {
-                        if (!isCheckViolation(checkResult)) {
-                            return;
-                        }
-                        const index = checkResultIndex(checkResult);
-                        context.report({
-                            loc: index === undefined
-                                ? firstPatternLoc(canonicalSource, spec.patterns ?? [])
-                                : locFromIndex(canonicalSource, index),
-                            message: spec.message,
-                            node,
-                        });
-                        return;
-                    }
-                    if (hasPattern(canonicalSource, spec.patterns ?? [])) {
-                        reportPatternMatches({ context, node, source: canonicalSource, spec });
-                    }
-                },
-            };
-        },
-    };
-}
-function makeRules(specs, options = {}) {
-    return Object.fromEntries(specs.map((spec) => [spec.name, makeProgramRule(spec, options)]));
-}
-function hasEffectSignal(source) {
-    const codeOnly = stripCommentsAndStrings(source);
-    return (hasEffectValueImport(source) ||
-        effectImportAliases(source).some((alias) => new RegExp(`\\b${escapeRegExp(alias)}\\.`, 'u').test(codeOnly)));
-}
-const runtimeCallPattern = /\b(?:Effect\.(?:runPromise|runPromiseExit|runSync|runSyncExit|runFork)|[A-Za-z_$][\w$]*Runtime\.runMain)\s*\(/;
-const boundaryFilePattern = /(?:^|\/)src\/(?:main|server|cli)\.ts$|\.entry\.ts$/;
-const testFilePattern = /\.(?:test|spec)\.tsx?$/;
-const ALIAS_CACHE_MAX = 256;
-const effectAliasCache = new Map();
-const runtimeFunctionAliasCache = new Map();
-const canonicalSourceCache = new Map();
-function cachedAliases(cache, source) {
-    const value = cache.get(source);
-    if (value) {
-        cache.delete(source);
-        cache.set(source, value);
-    }
-    return value;
-}
-function cacheAliases(cache, source, value) {
-    if (cache.size >= ALIAS_CACHE_MAX) {
-        const firstKey = cache.keys().next().value;
-        if (firstKey !== undefined) {
-            cache.delete(firstKey);
-        }
-    }
-    cache.set(source, value);
-    return value;
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function hasLocalEffectBinding(source) {
-    return /\b(?:const|let|var|function|class|namespace)\s+Effect\b/.test(stripCommentsAndStrings(source));
-}
-function importSpecifierNames(specifier) {
-    const trimmed = specifier.trim();
-    if (trimmed.startsWith('type ')) {
-        return undefined;
-    }
-    const parts = trimmed.split(/\s+as\s+/);
-    const importedName = parts[0]?.trim();
-    const localName = parts[1]?.trim() ?? importedName;
-    return importedName && localName ? { importedName, localName } : undefined;
-}
-function hasAnyEffectImport(source) {
-    return /(?:^|\n)\s*import(?:\s+type)?(?:[\s\S]*?\s+from\s*)?['"](?:effect(?:\/[^'"]+)?|@effect\/[^'"]+)['"]/.test(stripComments(source));
-}
-function hasEffectValueImport(source) {
-    const commentFreeSource = stripComments(source);
-    for (const match of commentFreeSource.matchAll(/(?:^|\n)\s*import\s+(?!type\b)\s*{([^}]+)}\s*from\s*['"]effect['"]/g)) {
-        if (match[1]
-            .split(',')
-            .some((specifier) => importSpecifierNames(specifier)?.importedName === 'Effect')) {
-            return true;
-        }
-    }
-    return (/(?:^|\n)\s*import\s+(?!type\b)\*\s+as\s+[A-Za-z_$][\w$]*\s+from\s*['"]effect(?:\/Effect)?['"]/.test(commentFreeSource) || effectFunctionAliases(source, 'Effect').length > 0);
-}
-function effectImportAliases(source) {
-    const cachedValue = cachedAliases(effectAliasCache, source);
-    if (cachedValue) {
-        return [...cachedValue];
-    }
-    const aliases = new Set();
-    const commentFreeSource = stripComments(source);
-    for (const match of commentFreeSource.matchAll(/(?:^|\n)\s*import\s+(?!type\b)\s*{([^}]+)}\s*from\s*['"]effect['"]/g)) {
-        for (const specifier of match[1].split(',')) {
-            const names = importSpecifierNames(specifier);
-            if (!names) {
-                continue;
-            }
-            if (names.importedName === 'Effect') {
-                aliases.add('Effect');
-                aliases.add(names.localName);
-            }
-        }
-    }
-    for (const match of commentFreeSource.matchAll(/(?:^|\n)\s*import\s+(?!type\b)\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s*['"]effect(?:\/Effect)?['"]/g)) {
-        aliases.add('Effect');
-        aliases.add(match[1]);
+};
+const isCheckViolation = (result) => {
+    if (typeof result === 'boolean') {
+        return result;
     }
-    if (aliases.size === 0 && !hasAnyEffectImport(source) && !hasLocalEffectBinding(source)) {
-        aliases.add('Effect');
+    return true;
+};
+const cachedSourceTokenPresence = (source) => {
+    let tokenPresence = sourceTokenPresenceCache.get(source);
+    if (tokenPresence !== undefined) {
+        return tokenPresence;
     }
-    return [...cacheAliases(effectAliasCache, source, [...aliases])];
-}
-function effectApiAliases(source, apiName) {
-    const aliases = new Set();
-    const commentFreeSource = stripComments(source);
-    for (const match of commentFreeSource.matchAll(/(?:^|\n)\s*import\s+(?!type\b)\s*{([^}]+)}\s*from\s*['"]effect['"]/g)) {
-        for (const specifier of match[1].split(',')) {
-            const names = importSpecifierNames(specifier);
-            if (names?.importedName === apiName) {
-                aliases.add(names.localName);
-            }
+    if (sourceTokenPresenceCache.size >= TOKEN_GATE_CACHE_MAX) {
+        const firstKey = sourceTokenPresenceCache.keys().next().value;
+        if (firstKey !== undefined) {
+            sourceTokenPresenceCache.delete(firstKey);
         }
     }
-    for (const match of commentFreeSource.matchAll(new RegExp(`(?:^|\\n)\\s*import\\s+(?!type\\b)\\*\\s+as\\s+([A-Za-z_$][\\w$]*)\\s+from\\s*['"]effect/${escapeRegExp(apiName)}['"]`, 'g'))) {
-        aliases.add(match[1]);
-    }
-    if (aliases.size === 0 && !hasAnyEffectImport(source)) {
-        aliases.add(apiName);
-    }
-    return [...aliases];
-}
-function effectFunctionAliases(source, moduleName, functionName) {
-    const aliases = new Set();
-    const commentFreeSource = stripComments(source);
-    for (const match of commentFreeSource.matchAll(new RegExp(`(?:^|\\n)\\s*import\\s+(?!type\\b)\\s*{([^}]+)}\\s*from\\s*['"]effect/${escapeRegExp(moduleName)}['"]`, 'g'))) {
-        for (const specifier of match[1].split(',')) {
-            const names = importSpecifierNames(specifier);
-            if (names && (!functionName || names.importedName === functionName)) {
-                aliases.add(names.localName);
-            }
-        }
+    tokenPresence = new Map();
+    sourceTokenPresenceCache.set(source, tokenPresence);
+    return tokenPresence;
+};
+const hasTokenInSourceCached = (source, token) => {
+    const tokenPresence = cachedSourceTokenPresence(source);
+    const cachedValue = tokenPresence.get(token);
+    if (cachedValue !== undefined) {
+        return cachedValue;
     }
-    return [...aliases];
-}
-function canonicalImportAliases(source) {
-    const aliases = new Map();
-    const commentFreeSource = stripComments(source);
-    const canonicalNames = new Set([
-        'Config',
-        'Context',
-        'Effect',
-        'Fiber',
-        'Layer',
-        'Queue',
-        'Schedule',
-        'Schema',
-        'Scope',
-        'Stream',
-        'TestClock',
-    ]);
-    for (const match of commentFreeSource.matchAll(/(?:^|\n)\s*import\s+(?!type\b)\s*{([^}]+)}\s*from\s*['"]effect['"]/g)) {
-        for (const specifier of match[1].split(',')) {
-            const names = importSpecifierNames(specifier);
-            const importedName = names?.importedName;
-            const localName = names?.localName;
-            if (importedName &&
-                localName &&
-                canonicalNames.has(importedName) &&
-                localName !== importedName) {
-                aliases.set(localName, importedName);
-            }
-        }
+    const hasToken = source.includes(token);
+    tokenPresence.set(token, hasToken);
+    return hasToken;
+};
+const hasAnyToken = (source, tokens) => tokens.some((token) => hasTokenInSourceCached(source, token));
+const cachedTokenGate = (source, tokens) => tokenGateCache.get(tokens)?.get(source);
+const cacheTokenGate = (source, tokens, hasToken) => {
+    let sourceCache = tokenGateCache.get(tokens);
+    if (!sourceCache) {
+        sourceCache = new Map();
+        tokenGateCache.set(tokens, sourceCache);
     }
-    for (const match of commentFreeSource.matchAll(/(?:^|\n)\s*import\s+(?!type\b)\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s*['"]effect\/([A-Za-z]+)['"]/g)) {
-        const [, localName, moduleName] = match;
-        if (canonicalNames.has(moduleName) && localName !== moduleName) {
-            aliases.set(localName, moduleName);
+    if (sourceCache.size >= TOKEN_GATE_CACHE_MAX) {
+        const firstKey = sourceCache.keys().next().value;
+        if (firstKey !== undefined) {
+            sourceCache.delete(firstKey);
         }
     }
-    return aliases;
-}
-function canonicalizeEffectApiAliases(source) {
-    const cachedValue = canonicalSourceCache.get(source);
+    sourceCache.set(source, hasToken);
+    return hasToken;
+};
+const hasAnyTokenCached = (source, tokens) => {
+    const cachedValue = cachedTokenGate(source, tokens);
     if (cachedValue !== undefined) {
-        canonicalSourceCache.delete(source);
-        canonicalSourceCache.set(source, cachedValue);
         return cachedValue;
     }
-    let canonicalSource = source;
-    for (const [localName, canonicalName] of canonicalImportAliases(source)) {
-        canonicalSource = canonicalSource.replace(new RegExp(`\\b${escapeRegExp(localName)}\\.`, 'g'), `${canonicalName}.`);
+    return cacheTokenGate(source, tokens, hasAnyToken(source, tokens));
+};
+const hasEveryTokenGroup = (source, tokenGroups) => tokenGroups.every((group) => hasAnyTokenCached(source, group));
+const shouldSkipSource = (source, requiredTokens, requiredTokenGroups) => source === '' ||
+    Boolean(requiredTokens && !hasAnyTokenCached(source, requiredTokens)) ||
+    Boolean(requiredTokenGroups && !hasEveryTokenGroup(source, requiredTokenGroups));
+const checkResultLOC = (source, spec, checkResult) => {
+    const index = checkResultIndex(checkResult);
+    if (index !== undefined) {
+        return locFromIndex(source, index);
     }
-    if (canonicalSourceCache.size >= ALIAS_CACHE_MAX) {
-        const firstKey = canonicalSourceCache.keys().next().value;
-        if (firstKey !== undefined) {
-            canonicalSourceCache.delete(firstKey);
+    return firstPatternLOC(source, spec.patterns ?? []);
+};
+const reportCheckResult = (context, node, source, spec, checkResult) => {
+    context.report({
+        loc: checkResultLOC(source, spec, checkResult),
+        message: effectDiagnosticMessage(spec.name, spec.message),
+        node,
+    });
+};
+const guidedContext = (context, spec) => ({
+    get filename() {
+        return context.filename;
+    },
+    get options() {
+        return context.options;
+    },
+    report(descriptor) {
+        context.report({
+            ...descriptor,
+            message: effectDiagnosticMessage(spec.name, descriptor.message),
+        });
+    },
+    get sourceCode() {
+        return context.sourceCode;
+    },
+});
+const runProgramRule = (input) => {
+    const { context, node, source, spec } = input;
+    const canonicalSource = canonicalizeEffectAPIAliases(source);
+    const checkResult = spec.check?.(canonicalSource, context);
+    if (checkResult !== undefined) {
+        if (!isCheckViolation(checkResult)) {
+            return;
         }
+        reportCheckResult(context, node, canonicalSource, spec, checkResult);
+        return;
     }
-    canonicalSourceCache.set(source, canonicalSource);
-    return canonicalSource;
-}
-function effectRuntimeFunctionAliases(source) {
-    const cachedValue = cachedAliases(runtimeFunctionAliasCache, source);
-    if (cachedValue) {
-        return [...cachedValue];
+    if (hasPattern(canonicalSource, spec.patterns ?? [])) {
+        reportPatternMatches({ context, node, source: canonicalSource, spec });
     }
-    const aliases = new Set();
-    const runtimeNames = new Set([
-        'runFork',
-        'runPromise',
-        'runPromiseExit',
-        'runSync',
-        'runSyncExit',
-    ]);
-    const commentFreeSource = stripComments(source);
-    for (const match of commentFreeSource.matchAll(/(?:^|\n)\s*import\s*{([^}]+)}\s*from\s*['"]effect\/Effect['"]/g)) {
-        for (const specifier of match[1].split(',')) {
-            const names = importSpecifierNames(specifier);
-            const importedName = names?.importedName;
-            const localName = names?.localName;
-            if (importedName && localName && runtimeNames.has(importedName)) {
-                aliases.add(localName);
+};
+const makeProgramOnlyRule = (spec, options) => {
+    const requiredTokens = spec.tokens ?? options.defaultTokens;
+    const requiredTokenGroups = spec.tokenGroups;
+    const rule = makeASTCapableRule(spec, options);
+    return {
+        ...rule,
+        createOnce(context) {
+            let source = '';
+            let isSkipped = true;
+            return {
+                Program(node) {
+                    if (isSkipped) {
+                        return;
+                    }
+                    runProgramRule({ context, node, source, spec });
+                },
+                before() {
+                    source = readSource(context);
+                    isSkipped = shouldSkipSource(source, requiredTokens, requiredTokenGroups);
+                    if (isSkipped) {
+                        return false;
+                    }
+                    return undefined;
+                },
+            };
+        },
+    };
+};
+const makeASTCapableRule = (spec, options) => {
+    const requiredTokens = spec.tokens ?? options.defaultTokens;
+    const requiredTokenGroups = spec.tokenGroups;
+    const rule = {
+        create(context) {
+            const source = readSource(context);
+            if (shouldSkipSource(source, requiredTokens, requiredTokenGroups)) {
+                return {
+                    Program() { },
+                };
             }
-        }
-    }
-    return [...cacheAliases(runtimeFunctionAliasCache, source, [...aliases])];
-}
-function hasRuntimeCall(source) {
-    const code = stripCommentsAndStrings(source);
-    if (runtimeCallPattern.test(code)) {
-        return true;
+            const astContext = guidedContext(context, spec);
+            const astVisitors = spec.ast?.(astContext, source) ?? {};
+            return {
+                ...astVisitors,
+                Program(node) {
+                    if (spec.ast && Array.isArray(node.body)) {
+                        return;
+                    }
+                    runProgramRule({ context, node, source, spec });
+                },
+            };
+        },
+        meta: {
+            docs: {
+                description: effectDiagnosticMessage(spec.name, spec.message),
+            },
+            schema: options.schema,
+            type: 'problem',
+        },
+    };
+    return rule;
+};
+const makeProgramRule = (spec, options) => {
+    if (spec.ast) {
+        return makeASTCapableRule(spec, options);
     }
-    return (effectImportAliases(source).some((alias) => new RegExp(`\\b${alias}\\.(?:runPromise|runPromiseExit|runSync|runSyncExit|runFork)\\s*\\(`).test(code)) ||
-        effectRuntimeFunctionAliases(source).some((alias) => new RegExp(`\\b${alias}\\s*\\(`).test(code)));
-}
-function isBoundaryFile(filename) {
-    return Boolean(filename && boundaryFilePattern.test(filename));
-}
-function isTestFile(filename) {
-    return Boolean(filename && testFilePattern.test(filename));
-}
-export { hasEffectSignal, effectApiAliases, effectFunctionAliases, effectImportAliases, hasRuntimeCall, isBoundaryFile, isTestFile, makeRules, runtimeCallPattern, };
+    return makeProgramOnlyRule(spec, options);
+};
+/**
+ * Internal helper exported for package-local composition.
+ *
+ * @internal
+ */
+export const makeRules = (specs, options = {}) => Object.fromEntries(specs.map((spec) => [spec.name, makeProgramRule(spec, options)]));
+export { effectAPIAliases, effectFunctionAliases, effectImportAliases, hasEffectSignal, hasRuntimeCall, isBoundaryFile, isTestFile, runtimeCallPattern, } from './effect-rule-aliases.js';
 //# sourceMappingURL=effect-rule-core.js.map