@seljs/checker 1.0.0 → 1.0.1

package/dist/utils/ast-utils.cjs

@@ -0,0 +1,164 @@
+//#region src/utils/ast-utils.ts
+const BINARY_OPS = new Set([
+	"==",
+	"!=",
+	"<",
+	"<=",
+	">",
+	">=",
+	"+",
+	"-",
+	"*",
+	"/",
+	"%",
+	"in",
+	"||",
+	"&&",
+	"[]",
+	"[?]"
+]);
+/**
+* Compute the source span {from, to} of an AST node.
+*
+* Uses the AST structure and `node.input` (original source) to calculate
+* positions. Does NOT use `serialize()` which normalizes whitespace,
+* quotes, and parentheses.
+*
+* Note: for binary operators, `node.pos` points to the operator token,
+* not the start of the expression. We compute `from` by finding the
+* leftmost descendant leaf position instead.
+*/
+const nodeSpan = (node) => {
+	const src = node.input;
+	if (node.op === "id") return {
+		from: node.pos,
+		to: node.pos + node.args.length
+	};
+	if (node.op === "value") return valueSpan(src, node.pos);
+	const children = collectChildren(node);
+	let minFrom = node.pos;
+	let maxTo = node.pos;
+	for (const child of children) {
+		const s = nodeSpan(child);
+		if (s.from < minFrom) minFrom = s.from;
+		if (s.to > maxTo) maxTo = s.to;
+	}
+	if (node.op === "!_" || node.op === "-_") minFrom = node.pos;
+	if (node.op === "." || node.op === ".?") {
+		const fieldName = node.args[1];
+		let i = maxTo;
+		while (i < src.length && src[i] !== ".") i++;
+		i++;
+		if (node.op === ".?" && i < src.length && src[i] === "?") i++;
+		i += fieldName.length;
+		return {
+			from: minFrom,
+			to: Math.min(i, src.length)
+		};
+	}
+	if (node.op === "call" || node.op === "rcall") return {
+		from: minFrom,
+		to: scanTo(src, maxTo, ")")
+	};
+	if (node.op === "list" || node.op === "[]" || node.op === "[?]") return {
+		from: minFrom,
+		to: scanTo(src, maxTo, "]")
+	};
+	if (node.op === "map") return {
+		from: minFrom,
+		to: scanTo(src, maxTo, "}")
+	};
+	return {
+		from: minFrom,
+		to: maxTo
+	};
+};
+/**
+* Depth-first walk of the AST, calling visitor on every node.
+*/
+const walkAST = (node, visitor, parent = null) => {
+	visitor(node, parent);
+	for (const child of collectChildren(node)) walkAST(child, visitor, node);
+};
+/**
+* Collect all ASTNode children of a node, regardless of op shape.
+*/
+const collectChildren = (node) => {
+	if (node.op === "value" || node.op === "id") return [];
+	if (node.op === "!_" || node.op === "-_") return [node.args];
+	if (BINARY_OPS.has(node.op)) {
+		const [left, right] = node.args;
+		return [left, right];
+	}
+	switch (node.op) {
+		case ".":
+		case ".?": {
+			const [receiver] = node.args;
+			return [receiver];
+		}
+		case "call": {
+			const [, callArgs] = node.args;
+			return callArgs;
+		}
+		case "rcall": {
+			const [, receiver, callArgs] = node.args;
+			return [receiver, ...callArgs];
+		}
+		case "list": return node.args;
+		case "map": return node.args.flat();
+		case "?:": {
+			const [cond, then, els] = node.args;
+			return [
+				cond,
+				then,
+				els
+			];
+		}
+		default: return [];
+	}
+};
+const valueSpan = (src, from) => {
+	const ch = src[from];
+	if (ch === "\"" || ch === "'") {
+		let i = from + 1;
+		while (i < src.length && src[i] !== ch) {
+			if (src[i] === "\\") i++;
+			i++;
+		}
+		return {
+			from,
+			to: i < src.length ? i + 1 : i
+		};
+	}
+	let i = from;
+	while (i < src.length && /[\w.]/.test(src[i] ?? "")) i++;
+	return {
+		from,
+		to: i
+	};
+};
+const scanTo = (src, from, ch) => {
+	let i = from;
+	while (i < src.length && src[i] !== ch) i++;
+	return i < src.length ? i + 1 : from;
+};
+const findNodeWithParentAt = (root, offset, parent = null) => {
+	const rootSpan = nodeSpan(root);
+	if (offset < rootSpan.from || offset >= rootSpan.to) return;
+	const children = collectChildren(root);
+	for (const child of children) {
+		const childSpan = nodeSpan(child);
+		if (offset >= childSpan.from && offset < childSpan.to) return findNodeWithParentAt(child, offset, root) ?? {
+			node: child,
+			parent: root
+		};
+	}
+	return {
+		node: root,
+		parent
+	};
+};
+//#endregion
+exports.findNodeWithParentAt = findNodeWithParentAt;
+exports.nodeSpan = nodeSpan;
+exports.walkAST = walkAST;

package/dist/utils/ast-utils.mjs

@@ -0,0 +1,162 @@
+//#region src/utils/ast-utils.ts
+const BINARY_OPS = new Set([
+	"==",
+	"!=",
+	"<",
+	"<=",
+	">",
+	">=",
+	"+",
+	"-",
+	"*",
+	"/",
+	"%",
+	"in",
+	"||",
+	"&&",
+	"[]",
+	"[?]"
+]);
+/**
+* Compute the source span {from, to} of an AST node.
+*
+* Uses the AST structure and `node.input` (original source) to calculate
+* positions. Does NOT use `serialize()` which normalizes whitespace,
+* quotes, and parentheses.
+*
+* Note: for binary operators, `node.pos` points to the operator token,
+* not the start of the expression. We compute `from` by finding the
+* leftmost descendant leaf position instead.
+*/
+const nodeSpan = (node) => {
+	const src = node.input;
+	if (node.op === "id") return {
+		from: node.pos,
+		to: node.pos + node.args.length
+	};
+	if (node.op === "value") return valueSpan(src, node.pos);
+	const children = collectChildren(node);
+	let minFrom = node.pos;
+	let maxTo = node.pos;
+	for (const child of children) {
+		const s = nodeSpan(child);
+		if (s.from < minFrom) minFrom = s.from;
+		if (s.to > maxTo) maxTo = s.to;
+	}
+	if (node.op === "!_" || node.op === "-_") minFrom = node.pos;
+	if (node.op === "." || node.op === ".?") {
+		const fieldName = node.args[1];
+		let i = maxTo;
+		while (i < src.length && src[i] !== ".") i++;
+		i++;
+		if (node.op === ".?" && i < src.length && src[i] === "?") i++;
+		i += fieldName.length;
+		return {
+			from: minFrom,
+			to: Math.min(i, src.length)
+		};
+	}
+	if (node.op === "call" || node.op === "rcall") return {
+		from: minFrom,
+		to: scanTo(src, maxTo, ")")
+	};
+	if (node.op === "list" || node.op === "[]" || node.op === "[?]") return {
+		from: minFrom,
+		to: scanTo(src, maxTo, "]")
+	};
+	if (node.op === "map") return {
+		from: minFrom,
+		to: scanTo(src, maxTo, "}")
+	};
+	return {
+		from: minFrom,
+		to: maxTo
+	};
+};
+/**
+* Depth-first walk of the AST, calling visitor on every node.
+*/
+const walkAST = (node, visitor, parent = null) => {
+	visitor(node, parent);
+	for (const child of collectChildren(node)) walkAST(child, visitor, node);
+};
+/**
+* Collect all ASTNode children of a node, regardless of op shape.
+*/
+const collectChildren = (node) => {
+	if (node.op === "value" || node.op === "id") return [];
+	if (node.op === "!_" || node.op === "-_") return [node.args];
+	if (BINARY_OPS.has(node.op)) {
+		const [left, right] = node.args;
+		return [left, right];
+	}
+	switch (node.op) {
+		case ".":
+		case ".?": {
+			const [receiver] = node.args;
+			return [receiver];
+		}
+		case "call": {
+			const [, callArgs] = node.args;
+			return callArgs;
+		}
+		case "rcall": {
+			const [, receiver, callArgs] = node.args;
+			return [receiver, ...callArgs];
+		}
+		case "list": return node.args;
+		case "map": return node.args.flat();
+		case "?:": {
+			const [cond, then, els] = node.args;
+			return [
+				cond,
+				then,
+				els
+			];
+		}
+		default: return [];
+	}
+};
+const valueSpan = (src, from) => {
+	const ch = src[from];
+	if (ch === "\"" || ch === "'") {
+		let i = from + 1;
+		while (i < src.length && src[i] !== ch) {
+			if (src[i] === "\\") i++;
+			i++;
+		}
+		return {
+			from,
+			to: i < src.length ? i + 1 : i
+		};
+	}
+	let i = from;
+	while (i < src.length && /[\w.]/.test(src[i] ?? "")) i++;
+	return {
+		from,
+		to: i
+	};
+};
+const scanTo = (src, from, ch) => {
+	let i = from;
+	while (i < src.length && src[i] !== ch) i++;
+	return i < src.length ? i + 1 : from;
+};
+const findNodeWithParentAt = (root, offset, parent = null) => {
+	const rootSpan = nodeSpan(root);
+	if (offset < rootSpan.from || offset >= rootSpan.to) return;
+	const children = collectChildren(root);
+	for (const child of children) {
+		const childSpan = nodeSpan(child);
+		if (offset >= childSpan.from && offset < childSpan.to) return findNodeWithParentAt(child, offset, root) ?? {
+			node: child,
+			parent: root
+		};
+	}
+	return {
+		node: root,
+		parent
+	};
+};
+//#endregion
+export { findNodeWithParentAt, nodeSpan, walkAST };

package/package.json

@@ -1,30 +1,36 @@
 {
   "name": "@seljs/checker",
-  "version": "1.0.0",
-  "type": "module",
+  "version": "1.0.1",
+  "repository": {
+    "url": "https://github.com/abinnovision/seljs"
+  },
   "license": "Apache-2.0",
   "author": {
     "name": "abi group GmbH",
     "email": "info@abigroup.io",
     "url": "https://abigroup.io/"
   },
-  "repository": {
-    "url": "https://github.com/abinnovision/seljs"
-  },
+  "type": "module",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     }
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.cts",
   "files": [
     "dist",
     "LICENSE.md"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "tsdown",
     "format:check": "prettier --check '{{src,test}/**/*,*}.{{t,j}s{,x},json{,5},md,y{,a}ml}'",
     "format:fix": "prettier --write '{{src,test}/**/*,*}.{{t,j}s{,x},json{,5},md,y{,a}ml}'",
     "lint:check": "eslint '{{src,test}/**/*,*}.{t,j}s{,x}'",
@@ -43,15 +49,12 @@
     ]
   },
   "dependencies": {
-    "@marcbachmann/cel-js": "^7.5.2",
-    "@seljs/common": "1.0.0",
-    "@seljs/schema": "1.0.0",
-    "@seljs/types": "1.0.0",
+    "@marcbachmann/cel-js": "^7.5.3",
+    "@seljs/common": "1.0.1",
+    "@seljs/schema": "1.0.1",
+    "@seljs/types": "1.0.1",
     "debug": "^4.4.3"
   },
-  "peerDependencies": {
-    "zod": "^4.0.0"
-  },
   "devDependencies": {
     "@abinnovision/eslint-config-base": "^3.2.0",
     "@abinnovision/prettier-config": "^2.1.5",
@@ -59,10 +62,14 @@
     "@types/debug": "^4.1.12",
     "eslint": "^9.39.4",
     "prettier": "^3.8.1",
+    "tsdown": "^0.21.3",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18",
     "zod": "^4.3.6"
   },
+  "peerDependencies": {
+    "zod": "^4.0.0"
+  },
   "publishConfig": {
     "npm": true,
     "npmAccess": "public"

package/dist/checker/checker.d.ts

@@ -1,173 +0,0 @@
-import type { SELRule } from "../rules/index.js";
-import type { SELSchema } from "@seljs/schema";
-interface SELCheckResult {
-    valid: boolean;
-    type?: string;
-    diagnostics: SELDiagnostic[];
-}
-interface TypeAtResult {
-    type: string;
-    from: number;
-    to: number;
-}
-interface ExpectedTypeInfo {
-    /**
-     * The CEL type expected at this position.
-     */
-    expectedType: string;
-    /**
-     * How the expectation was inferred.
-     */
-    context: "operator" | "function-argument";
-    /**
-     * For function args: which parameter index.
-     */
-    paramIndex?: number;
-    /**
-     * For function args: the function/method name.
-     */
-    functionName?: string;
-}
-interface CompletionInfo {
-    kind: "top-level" | "dot-access" | "explicit";
-    receiverType?: string;
-    items: CompletionItem[];
-    /**
-     * Inferred expected type at cursor, if determinable.
-     */
-    expectedType?: string;
-}
-export interface CompletionItem {
-    label: string;
-    type: string;
-    detail?: string;
-    description?: string;
-}
-/**
- * A diagnostic message with optional position info. Used for both parse/type errors
- * and rule violations. Positions are optional because some errors (e.g. from cel-js)
- * may not include reliable spans, and rules may choose to report non-positional issues.
- */
-export interface SELDiagnostic {
-    message: string;
-    severity: "error" | "warning" | "info";
-    from?: number;
-    to?: number;
-}
-/**
- * Options for configuring the SELChecker.
- */
-export interface SELCheckerOptions {
-    /**
-     * Lint rules to enable. Defaults to none (backward compatible).
-     */
-    rules?: readonly SELRule[];
-}
-/**
- * SEL expression checker.
- *
- * Wraps a hydrated cel-js Environment built from a SELSchema and exposes
- * parse/type-check, type inference, cursor-position type lookups, and
- * type-aware completions.
- */
-export declare class SELChecker {
-    private readonly rules;
-    private env;
-    private schema;
-    private structTypeMap;
-    constructor(schema: SELSchema, options?: SELCheckerOptions);
-    /**
-     * Parse and type-check an expression, returning position-aware diagnostics.
-     *
-     * Uses a single `env.parse()` call, then `.check()` on the result
-     * to avoid double-parsing. Rules run against the AST from the same parse:
-     * - Structural rules run after successful parse (even if type-check fails)
-     * - Type-aware rules run only after both parse and type-check succeed
-     */
-    check(expression: string): SELCheckResult;
-    /**
-     * Get the inferred CEL type of the full expression.
-     * Returns undefined if the expression is invalid.
-     */
-    typeOf(expression: string): string | undefined;
-    /**
-     * Get the inferred type at a cursor position (for hover info).
-     *
-     * Attempts to identify the sub-expression under the cursor and infer its
-     * type. Falls back to the full expression type when sub-expression
-     * isolation is not possible.
-     */
-    typeAt(expression: string, offset: number): TypeAtResult | undefined;
-    /**
-     * Get type-aware completions for a cursor context.
-     *
-     * Supports:
-     * - **dot-access**: after `contract.` — lists methods of that contract
-     * - **top-level**: at the start or after operators — lists variables,
-     *   contracts, and functions
-     */
-    completionsAt(expression: string, offset: number): CompletionInfo;
-    /**
-     * Infer the expected type at a cursor position from surrounding context.
-     *
-     * Supports two contexts:
-     * - **Operator**: `expr > |` — infers the left operand type and derives the
-     *   expected right operand type from the operator.
-     * - **Function argument**: `contract.method(arg, |)` — looks up the
-     *   parameter type from the schema.
-     *
-     * Returns undefined when context cannot be determined, signaling that
-     * no narrowing should occur (safe fallback).
-     */
-    expectedTypeAt(expression: string, offset: number): ExpectedTypeInfo | undefined;
-    /**
-     * Resolve type and available members for a dot-access receiver expression.
-     */
-    dotCompletions(receiverExpression: string): CompletionInfo;
-    /**
-     * Resolve expected type from a structured context.
-     */
-    expectedTypeFor(context: {
-        kind: "operator";
-        leftExpression: string;
-        operator: string;
-    } | {
-        kind: "function-arg";
-        receiverName?: string;
-        functionName: string;
-        paramIndex: number;
-    }): string | undefined;
-    /**
-     * Rebuild the internal environment from an updated schema.
-     */
-    updateSchema(schema: SELSchema): void;
-    private buildStructTypeMap;
-    private structFieldsFor;
-    /**
-     * Scan backwards from a dot position to extract the receiver expression.
-     * Handles balanced parentheses so that `foo(erc20.name().` correctly
-     * identifies `erc20.name()` as the receiver, not `foo(erc20.name()`.
-     */
-    private extractReceiverBefore;
-    /**
-     * Find the largest call/dot-access chain node that contains the offset.
-     */
-    private findContainingChain;
-    /**
-     * Scan backwards from the end of text to find a trailing binary operator.
-     * Tries multi-character operators first (==, !=, etc.) to avoid partial matches.
-     */
-    private findTrailingOperator;
-    /**
-     * Find the enclosing function/method call around the cursor by scanning
-     * backwards for an unclosed `(`, then extracting the function name and
-     * counting commas to determine the parameter index.
-     */
-    private findEnclosingCall;
-    /**
-     * Look up the expected parameter type from the schema for a function or
-     * method call at the given parameter index.
-     */
-    private resolveRawParamType;
-}
-export {};