@amritk/lint 0.0.0 → 0.1.0

package/dist/parsers/lines.js

@@ -0,0 +1,28 @@
+/**
+ * Builds a {@link LineMap} for `source`. The line-start offsets are precomputed
+ * once so each `positionAt` lookup is a binary search rather than a re-scan.
+ */
+export const createLineMap = (source) => {
+    const length = source.length;
+    // Offset at which each line starts. lineStarts[0] === 0.
+    const lineStarts = [0];
+    for (let i = 0; i < source.length; i++) {
+        if (source.charCodeAt(i) === 10 /* \n */)
+            lineStarts.push(i + 1);
+    }
+    const positionAt = (offset) => {
+        const clamped = Math.max(0, Math.min(offset, length));
+        // Binary search for the last line start <= clamped.
+        let low = 0;
+        let high = lineStarts.length - 1;
+        while (low < high) {
+            const mid = (low + high + 1) >> 1;
+            if ((lineStarts[mid] ?? 0) <= clamped)
+                low = mid;
+            else
+                high = mid - 1;
+        }
+        return { line: low, character: clamped - (lineStarts[low] ?? 0) };
+    };
+    return { positionAt };
+};

package/dist/parsers/types.d.ts

@@ -0,0 +1,50 @@
+/** A path into a parsed document: object keys and array indices from the root. */
+export type JsonPath = (string | number)[];
+/** A zero-based line/character position, matching LSP and Linter conventions. */
+export type IPosition = {
+    /** Zero-based line number. */
+    line: number;
+    /** Zero-based character offset within the line. */
+    character: number;
+};
+/** An inclusive-start, exclusive-end span between two positions. */
+export type IRange = {
+    start: IPosition;
+    end: IPosition;
+};
+/** A resolved source location — currently just the range a node occupies. */
+export type ILocation = {
+    range: IRange;
+};
+/** Severity levels, ordered most-to-least severe to match LSP's numeric scale. */
+export declare enum DiagnosticSeverity {
+    Error = 0,
+    Warning = 1,
+    Information = 2,
+    Hint = 3
+}
+/** A problem reported by the parser itself (e.g. a syntax or duplicate-key error). */
+export type IDiagnostic = {
+    code?: string | number;
+    message: string;
+    path?: JsonPath;
+    range: IRange;
+    severity: DiagnosticSeverity;
+};
+/** The result of parsing a document: its data, parser diagnostics, and a position lookup. */
+export type IParseResult<T = unknown> = {
+    data: T;
+    diagnostics: IDiagnostic[];
+    /**
+     * Returns the source location for a JSON path. When `closest` is true and the
+     * exact path is not found, walks up to the nearest ancestor that is.
+     */
+    getLocationForJsonPath(path: JsonPath, closest?: boolean): ILocation | undefined;
+};
+/** Tuning for how strictly the parser treats YAML/JSON edge cases. */
+export type IParserOptions = {
+    /** Severity for duplicate object keys. Default: error. `false`/`"off"` disables. */
+    duplicateKeys?: DiagnosticSeverity | 'off' | false;
+    /** Severity for YAML values incompatible with JSON (e.g. bigints). Default: error. */
+    incompatibleValues?: DiagnosticSeverity | 'off' | false;
+};

package/dist/parsers/types.js

@@ -0,0 +1,8 @@
+/** Severity levels, ordered most-to-least severe to match LSP's numeric scale. */
+export var DiagnosticSeverity;
+(function (DiagnosticSeverity) {
+    DiagnosticSeverity[DiagnosticSeverity["Error"] = 0] = "Error";
+    DiagnosticSeverity[DiagnosticSeverity["Warning"] = 1] = "Warning";
+    DiagnosticSeverity[DiagnosticSeverity["Information"] = 2] = "Information";
+    DiagnosticSeverity[DiagnosticSeverity["Hint"] = 3] = "Hint";
+})(DiagnosticSeverity || (DiagnosticSeverity = {}));

package/dist/parsers/yaml.d.ts

@@ -0,0 +1,6 @@
+import { type IParseResult, type IParserOptions } from './types.js';
+/**
+ * Parses YAML (a JSON superset, so this handles both) into data plus a source
+ * map, surfacing duplicate-key and incompatible-value diagnostics per `options`.
+ */
+export declare const parseYaml: <T = unknown>(source: string, options?: IParserOptions) => IParseResult<T>;

package/dist/parsers/yaml.js

@@ -0,0 +1,65 @@
+import { isMap, isPair, isScalar, isSeq, parseDocument } from '@amritk/yaml';
+import { createLineMap } from './lines.js';
+import { DiagnosticSeverity, } from './types.js';
+const pathKey = (path) => path.join('\0');
+/**
+ * Parses YAML (a JSON superset, so this handles both) into data plus a source
+ * map, surfacing duplicate-key and incompatible-value diagnostics per `options`.
+ */
+export const parseYaml = (source, options = {}) => {
+    const lineMap = createLineMap(source);
+    const dedupe = options.duplicateKeys === 'off' || options.duplicateKeys === false;
+    const doc = parseDocument(source, { uniqueKeys: !dedupe });
+    const index = new Map();
+    const rangeOf = (node) => ({
+        start: lineMap.positionAt(node.start),
+        end: lineMap.positionAt(node.end),
+    });
+    const walk = (node, path) => {
+        if (node == null)
+            return;
+        index.set(pathKey(path), rangeOf(node));
+        if (isMap(node)) {
+            for (const item of node.items) {
+                if (!isPair(item))
+                    continue;
+                const key = item.key;
+                const keyName = isScalar(key) ? key.value : String(key);
+                walk(item.value, [...path, keyName]);
+            }
+        }
+        else if (isSeq(node)) {
+            node.items.forEach((item, i) => {
+                walk(item, [...path, i]);
+            });
+        }
+    };
+    walk(doc.contents, []);
+    const data = doc.toJS();
+    const diagnostics = [];
+    const pushError = (severity, message, start, end) => {
+        diagnostics.push({
+            message,
+            severity,
+            range: { start: lineMap.positionAt(start), end: lineMap.positionAt(end) },
+        });
+    };
+    for (const err of doc.errors) {
+        pushError(DiagnosticSeverity.Error, err.message, err.start, err.end);
+    }
+    for (const warn of doc.warnings) {
+        pushError(DiagnosticSeverity.Warning, warn.message, warn.start, warn.end);
+    }
+    const getLocationForJsonPath = (path, closest = false) => {
+        const p = path.slice();
+        while (true) {
+            const range = index.get(pathKey(p));
+            if (range)
+                return { range };
+            if (!closest || p.length === 0)
+                return undefined;
+            p.pop();
+        }
+    };
+    return { data, diagnostics, getLocationForJsonPath };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/lint",
-  "version": "0.0.0",
+  "version": "0.1.0",
   "description": "A fast, format-agnostic JSON/YAML style-guide linter with JSON Schema and custom rules.",
   "module": "./dist/index.js",
   "type": "module",
@@ -40,14 +40,13 @@
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "development": "./src/index.ts",
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     }
   },
   "dependencies": {
-    "@amritk/runtime-validators": "workspace:*",
-    "@amritk/yaml": "workspace:*",
+    "@amritk/runtime-validators": "0.6.4",
+    "@amritk/yaml": "0.2.3",
     "jsonc-parser": "^3.3.1"
   }
 }