@emeryld/manager 1.4.12 → 1.4.15

package/dist/eslint-plugin-format-checker/index.js

@@ -0,0 +1,150 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { DEFAULT_LIMITS } from '../format-checker/config.js';
+import { analyzeFileContent } from '../format-checker/scan/index.js';
+import { collectDuplicateViolations } from '../format-checker/scan/duplicates.js';
+function asPositiveInt(value, fallback) {
+    const num = Number(value);
+    if (!Number.isFinite(num))
+        return fallback;
+    const floored = Math.floor(num);
+    return floored <= 0 ? fallback : floored;
+}
+function asNonNegativeInt(value, fallback) {
+    const num = Number(value);
+    if (!Number.isFinite(num))
+        return fallback;
+    const floored = Math.floor(num);
+    return floored < 0 ? fallback : floored;
+}
+function buildLimits(rawOptions) {
+    const options = rawOptions && typeof rawOptions === 'object' ? rawOptions : {};
+    return {
+        ...BASE_LIMITS,
+        maxFunctionLength: asPositiveInt(options.maxFunctionLength, BASE_LIMITS.maxFunctionLength),
+        maxMethodLength: asPositiveInt(options.maxMethodLength, BASE_LIMITS.maxMethodLength),
+        maxIndentationDepth: asPositiveInt(options.maxIndentationDepth, BASE_LIMITS.maxIndentationDepth),
+        maxFunctionsPerFile: asPositiveInt(options.maxFunctionsPerFile, BASE_LIMITS.maxFunctionsPerFile),
+        maxComponentsPerFile: asPositiveInt(options.maxComponentsPerFile, BASE_LIMITS.maxComponentsPerFile),
+        maxFileLength: asPositiveInt(options.maxFileLength, BASE_LIMITS.maxFileLength),
+        maxDuplicateLineOccurrences: asPositiveInt(options.maxDuplicateLineOccurrences, BASE_LIMITS.maxDuplicateLineOccurrences),
+        minDuplicateLines: asNonNegativeInt(options.minDuplicateLines, BASE_LIMITS.minDuplicateLines),
+        exportOnly: typeof options.exportOnly === 'boolean'
+            ? options.exportOnly
+            : BASE_LIMITS.exportOnly,
+        indentationWidth: asPositiveInt(options.indentationWidth, BASE_LIMITS.indentationWidth),
+        reportingMode: BASE_LIMITS.reportingMode,
+    };
+}
+function loadWorkspaceDefaults() {
+    const settingsPath = path.join(process.cwd(), '.vscode', 'settings.json');
+    if (!existsSync(settingsPath))
+        return DEFAULT_LIMITS;
+    try {
+        const raw = readFileSync(settingsPath, 'utf-8');
+        const json = JSON.parse(raw);
+        const settings = json?.['manager.formatChecker'];
+        if (!settings || typeof settings !== 'object')
+            return DEFAULT_LIMITS;
+        return {
+            ...DEFAULT_LIMITS,
+            maxFunctionLength: asPositiveInt(settings.maxFunctionLength, DEFAULT_LIMITS.maxFunctionLength),
+            maxMethodLength: asPositiveInt(settings.maxMethodLength, DEFAULT_LIMITS.maxMethodLength),
+            maxIndentationDepth: asPositiveInt(settings.maxIndentationDepth, DEFAULT_LIMITS.maxIndentationDepth),
+            maxFunctionsPerFile: asPositiveInt(settings.maxFunctionsPerFile, DEFAULT_LIMITS.maxFunctionsPerFile),
+            maxComponentsPerFile: asPositiveInt(settings.maxComponentsPerFile, DEFAULT_LIMITS.maxComponentsPerFile),
+            maxFileLength: asPositiveInt(settings.maxFileLength, DEFAULT_LIMITS.maxFileLength),
+            maxDuplicateLineOccurrences: asPositiveInt(settings.maxDuplicateLineOccurrences, DEFAULT_LIMITS.maxDuplicateLineOccurrences),
+            minDuplicateLines: asNonNegativeInt(settings.minDuplicateLines, DEFAULT_LIMITS.minDuplicateLines),
+            exportOnly: typeof settings.exportOnly === 'boolean'
+                ? settings.exportOnly
+                : DEFAULT_LIMITS.exportOnly,
+            indentationWidth: asPositiveInt(settings.indentationWidth, DEFAULT_LIMITS.indentationWidth),
+        };
+    }
+    catch {
+        return DEFAULT_LIMITS;
+    }
+}
+const BASE_LIMITS = loadWorkspaceDefaults();
+function parseDetailRange(detail) {
+    if (typeof detail !== 'string')
+        return undefined;
+    const match = /^(\d+):(\d+)\/(\d+):(\d+)$/.exec(detail);
+    if (!match)
+        return undefined;
+    return {
+        startLine: Number(match[1]),
+        startColumn: Number(match[2]),
+        endLine: Number(match[3]),
+        endColumn: Number(match[4]),
+    };
+}
+function locFromViolation(violation) {
+    const parsed = parseDetailRange(violation.detail);
+    if (parsed) {
+        return {
+            start: { line: parsed.startLine, column: Math.max(0, parsed.startColumn - 1) },
+            end: { line: parsed.endLine, column: Math.max(0, parsed.endColumn - 1) },
+        };
+    }
+    const line = typeof violation.line === 'number' && violation.line > 0 ? violation.line : 1;
+    return {
+        start: { line, column: 0 },
+        end: { line, column: 0 },
+    };
+}
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Runs @emeryld/manager format-checker heuristics as ESLint diagnostics.',
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    maxFunctionLength: { type: 'integer', minimum: 1 },
+                    maxMethodLength: { type: 'integer', minimum: 1 },
+                    maxIndentationDepth: { type: 'integer', minimum: 1 },
+                    maxFunctionsPerFile: { type: 'integer', minimum: 1 },
+                    maxComponentsPerFile: { type: 'integer', minimum: 1 },
+                    maxFileLength: { type: 'integer', minimum: 1 },
+                    maxDuplicateLineOccurrences: { type: 'integer', minimum: 1 },
+                    minDuplicateLines: { type: 'integer', minimum: 0 },
+                    exportOnly: { type: 'boolean' },
+                    indentationWidth: { type: 'integer', minimum: 1 },
+                },
+            },
+        ],
+    },
+    create(context) {
+        const filename = context.getFilename?.() ?? '<text>';
+        if (!filename || filename === '<input>' || filename === '<text>')
+            return {};
+        if (filename.endsWith('.d.ts'))
+            return {};
+        const limits = buildLimits(context.options?.[0]);
+        return {
+            Program() {
+                const sourceCode = context.getSourceCode();
+                const duplicates = new Map();
+                const fileSnapshots = new Map();
+                const violations = analyzeFileContent(filename, sourceCode.text, limits, duplicates, fileSnapshots);
+                const duplicateViolations = collectDuplicateViolations(duplicates, limits, fileSnapshots);
+                for (const violation of [...violations, ...duplicateViolations]) {
+                    context.report({
+                        loc: locFromViolation(violation),
+                        message: `format-checker (${violation.type}): ${violation.message}`,
+                    });
+                }
+            },
+        };
+    },
+};
+export default {
+    rules: {
+        'format-checker': rule,
+    },
+};

package/dist/format-checker/scan/analysis.js

@@ -16,14 +16,7 @@ export async function analyzeFiles(files, limits) {
     violations.push(...collectDuplicateViolations(duplicateMap, limits, fileSnapshots));
     return violations;
 }
-async function analyzeSingleFile(filePath, limits, duplicates, fileSnapshots) {
-    let content;
-    try {
-        content = await readFile(filePath, 'utf-8');
-    }
-    catch {
-        return [];
-    }
+export function analyzeFileContent(filePath, content, limits, duplicates, fileSnapshots) {
     const lines = content.split(/\r?\n/);
     const importFlags = markImportLines(lines);
     const normalizedLines = lines.map((line, index) => ({
@@ -114,3 +107,13 @@ async function analyzeSingleFile(filePath, limits, duplicates, fileSnapshots) {
     });
     return violations;
 }
+async function analyzeSingleFile(filePath, limits, duplicates, fileSnapshots) {
+    let content;
+    try {
+        content = await readFile(filePath, 'utf-8');
+    }
+    catch {
+        return [];
+    }
+    return analyzeFileContent(filePath, content, limits, duplicates, fileSnapshots);
+}

package/dist/format-checker/scan/index.js

@@ -1,2 +1,3 @@
 export { collectSourceFiles } from './collect.js';
 export { analyzeFiles } from './analysis.js';
+export { analyzeFileContent } from './analysis.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emeryld/manager",
-  "version": "1.4.12",
+  "version": "1.4.15",
   "description": "Interactive manager for pnpm monorepos (update/test/build/publish).",
   "license": "MIT",
   "type": "module",