@seljs/editor 1.0.0 → 1.0.1-beta.9

package/dist/completion/completion-items.cjs

@@ -0,0 +1,36 @@
+//#region src/completion/completion-items.ts
+const createContractCompletions = (contracts) => contracts.map((c) => ({
+	label: c.name,
+	type: "class",
+	detail: c.description
+}));
+const createMethodCompletions = (contract) => contract.methods.map((m) => ({
+	label: m.name,
+	type: "method",
+	detail: `(${m.params.map((p) => `${p.name}: ${p.type}`).join(", ")}): ${m.returns}`,
+	info: m.description
+}));
+const createFunctionCompletions = (functions) => functions.map((f) => ({
+	label: f.name,
+	type: "function",
+	detail: f.signature,
+	info: f.description
+}));
+const createMacroCompletions = (macros) => macros.map((m) => ({
+	label: m.name,
+	type: "keyword",
+	detail: m.pattern,
+	info: m.description
+}));
+const createVariableCompletions = (variables) => variables.map((v) => ({
+	label: v.name,
+	type: "variable",
+	detail: v.type,
+	info: v.description
+}));
+//#endregion
+exports.createContractCompletions = createContractCompletions;
+exports.createFunctionCompletions = createFunctionCompletions;
+exports.createMacroCompletions = createMacroCompletions;
+exports.createMethodCompletions = createMethodCompletions;
+exports.createVariableCompletions = createVariableCompletions;

package/dist/completion/completion-items.mjs

@@ -0,0 +1,32 @@
+//#region src/completion/completion-items.ts
+const createContractCompletions = (contracts) => contracts.map((c) => ({
+	label: c.name,
+	type: "class",
+	detail: c.description
+}));
+const createMethodCompletions = (contract) => contract.methods.map((m) => ({
+	label: m.name,
+	type: "method",
+	detail: `(${m.params.map((p) => `${p.name}: ${p.type}`).join(", ")}): ${m.returns}`,
+	info: m.description
+}));
+const createFunctionCompletions = (functions) => functions.map((f) => ({
+	label: f.name,
+	type: "function",
+	detail: f.signature,
+	info: f.description
+}));
+const createMacroCompletions = (macros) => macros.map((m) => ({
+	label: m.name,
+	type: "keyword",
+	detail: m.pattern,
+	info: m.description
+}));
+const createVariableCompletions = (variables) => variables.map((v) => ({
+	label: v.name,
+	type: "variable",
+	detail: v.type,
+	info: v.description
+}));
+//#endregion
+export { createContractCompletions, createFunctionCompletions, createMacroCompletions, createMethodCompletions, createVariableCompletions };

package/dist/completion/index.cjs

@@ -0,0 +1 @@
+require("./schema-completion.cjs");

package/dist/completion/index.d.mts

@@ -0,0 +1 @@
+import { SchemaCompletionProvider, createSchemaCompletion } from "./schema-completion.mjs";

package/dist/completion/index.mjs

@@ -0,0 +1,2 @@
+import "./schema-completion.mjs";
+export {};

package/dist/completion/schema-completion.cjs

@@ -0,0 +1,182 @@
+const require_completion_items = require("./completion-items.cjs");
+const require_tree_context = require("./tree-context.cjs");
+let _codemirror_autocomplete = require("@codemirror/autocomplete");
+let _seljs_checker = require("@seljs/checker");
+//#region src/completion/schema-completion.ts
+/**
+* Determine the CodeMirror completion type from a checker CompletionItem.
+* Method details start with "(" (e.g., "(owner: sol_address): sol_int"),
+* while struct field details are plain type names (e.g., "sol_int").
+*/
+const completionKind = (item) => item.detail?.startsWith("(") ? "method" : "property";
+var SchemaCompletionProvider = class {
+	topLevelCompletions;
+	allDotCompletions;
+	checker;
+	constructor(schema, checker) {
+		this.checker = checker;
+		const contractCompletions = require_completion_items.createContractCompletions(schema.contracts);
+		const variableCompletions = require_completion_items.createVariableCompletions(schema.variables);
+		const functionCompletions = require_completion_items.createFunctionCompletions(schema.functions.filter((f) => !f.receiverType));
+		const macroCompletions = require_completion_items.createMacroCompletions(schema.macros);
+		const atomCompletions = [
+			{
+				label: "true",
+				type: "keyword"
+			},
+			{
+				label: "false",
+				type: "keyword"
+			},
+			{
+				label: "null",
+				type: "keyword"
+			}
+		];
+		this.topLevelCompletions = [
+			...contractCompletions,
+			...variableCompletions,
+			...functionCompletions,
+			...atomCompletions
+		];
+		const allMethods = [];
+		for (const contract of schema.contracts) allMethods.push(...require_completion_items.createMethodCompletions(contract));
+		const structFields = [];
+		for (const type of schema.types) if (type.kind === "struct" && type.fields) for (const field of type.fields) structFields.push({
+			label: field.name,
+			type: "property",
+			detail: field.type,
+			info: field.description
+		});
+		const receiverMethods = [];
+		for (const fn of schema.functions) if (fn.receiverType) receiverMethods.push({
+			label: fn.name,
+			type: "method",
+			detail: fn.signature,
+			info: fn.description
+		});
+		this.allDotCompletions = [
+			...allMethods,
+			...macroCompletions,
+			...structFields,
+			...receiverMethods
+		];
+	}
+	completionSource = (context) => {
+		const treeCtx = require_tree_context.getCompletionContext(context.state, context.pos);
+		switch (treeCtx.kind) {
+			case "dot-access": return this.handleDotAccess(context, treeCtx);
+			case "call-arg": return this.handleCallArg(context, treeCtx);
+			case "top-level": return this.handleTopLevel(context, treeCtx);
+		}
+	};
+	handleDotAccess(context, treeCtx) {
+		const { receiverText, from } = treeCtx;
+		if (/^\d+$/.test(receiverText)) return this.handleTopLevel(context, {
+			kind: "top-level",
+			from
+		});
+		const info = this.checker.dotCompletions(receiverText);
+		if (info.items.length > 0) return {
+			from,
+			options: info.items.map((item) => ({
+				label: item.label,
+				type: completionKind(item),
+				detail: item.detail,
+				info: item.description
+			})),
+			filter: true
+		};
+		if (info.receiverType !== receiverText) return null;
+		return this.allDotCompletions.length ? {
+			from,
+			options: this.allDotCompletions,
+			filter: true
+		} : null;
+	}
+	handleCallArg(context, treeCtx) {
+		const expectedType = this.checker.expectedTypeFor({
+			kind: "function-arg",
+			functionName: treeCtx.functionName,
+			receiverName: treeCtx.receiverName,
+			paramIndex: treeCtx.paramIndex
+		});
+		if (expectedType) {
+			const filtered = this.topLevelCompletions.filter((c) => {
+				if (c.type === "keyword") {
+					if (c.label === "null") return true;
+					if (c.label === "true" || c.label === "false") return (0, _seljs_checker.isTypeCompatible)("bool", expectedType);
+				}
+				if (c.type === "variable" && c.detail) return (0, _seljs_checker.isTypeCompatible)(c.detail, expectedType);
+				if (c.type === "class" && c.label) return (0, _seljs_checker.isTypeCompatible)(`SEL_Contract_${c.label}`, expectedType);
+				return true;
+			});
+			if (filtered.length > 0) return {
+				from: context.matchBefore(/\w+/)?.from ?? treeCtx.from,
+				options: filtered,
+				filter: true
+			};
+		}
+		return this.handleTopLevel(context, {
+			kind: "top-level",
+			from: treeCtx.from
+		});
+	}
+	handleTopLevel(context, treeCtx) {
+		const wordMatch = context.matchBefore(/\w+/);
+		const from = wordMatch?.from ?? treeCtx.from;
+		const hasText = !!wordMatch;
+		const narrowed = this.narrowByExpectedType(context, from);
+		if (narrowed && narrowed.length > 0) return {
+			from,
+			options: narrowed,
+			filter: true
+		};
+		if (hasText) return this.topLevelCompletions.length ? {
+			from,
+			options: this.topLevelCompletions,
+			filter: true
+		} : null;
+		if (context.explicit && this.topLevelCompletions.length) return {
+			from: context.pos,
+			options: this.topLevelCompletions,
+			filter: true
+		};
+		return null;
+	}
+	/**
+	* Use the checker to infer the expected type at cursor position
+	* and filter completions to only type-compatible items.
+	* Returns undefined when narrowing is not possible.
+	*/
+	narrowByExpectedType(context, from) {
+		const doc = context.state.doc.toString();
+		const info = this.checker.completionsAt(doc, from);
+		if (!info.expectedType) return;
+		const expectedType = info.expectedType;
+		const filtered = info.items.filter((item) => (0, _seljs_checker.isTypeCompatible)(item.type, expectedType)).map((item) => ({
+			label: item.label,
+			type: item.type.startsWith("SEL_Contract_") ? "class" : item.detail ? "function" : "variable",
+			detail: item.detail ?? item.type,
+			info: item.description
+		}));
+		if ((0, _seljs_checker.isTypeCompatible)("bool", expectedType)) filtered.push({
+			label: "true",
+			type: "keyword"
+		}, {
+			label: "false",
+			type: "keyword"
+		});
+		filtered.push({
+			label: "null",
+			type: "keyword"
+		});
+		return filtered.length > 0 ? filtered : void 0;
+	}
+};
+const createSchemaCompletion = (schema, checker) => {
+	return (0, _codemirror_autocomplete.autocompletion)({ override: [new SchemaCompletionProvider(schema, checker).completionSource] });
+};
+//#endregion
+exports.SchemaCompletionProvider = SchemaCompletionProvider;
+exports.createSchemaCompletion = createSchemaCompletion;

package/dist/completion/schema-completion.d.cts

@@ -0,0 +1,25 @@
+import { SELSchema } from "@seljs/schema";
+import { CompletionContext, CompletionResult } from "@codemirror/autocomplete";
+import { Extension } from "@codemirror/state";
+import { SELChecker } from "@seljs/checker";
+
+//#region src/completion/schema-completion.d.ts
+declare class SchemaCompletionProvider {
+  private topLevelCompletions;
+  private allDotCompletions;
+  private checker;
+  constructor(schema: SELSchema, checker: SELChecker);
+  completionSource: (context: CompletionContext) => CompletionResult | null;
+  private handleDotAccess;
+  private handleCallArg;
+  private handleTopLevel;
+  /**
+   * Use the checker to infer the expected type at cursor position
+   * and filter completions to only type-compatible items.
+   * Returns undefined when narrowing is not possible.
+   */
+  private narrowByExpectedType;
+}
+declare const createSchemaCompletion: (schema: SELSchema, checker: SELChecker) => Extension;
+//#endregion
+export { SchemaCompletionProvider, createSchemaCompletion };

package/dist/completion/schema-completion.d.mts

@@ -0,0 +1,25 @@
+import { CompletionContext, CompletionResult } from "@codemirror/autocomplete";
+import { SELChecker } from "@seljs/checker";
+import { Extension } from "@codemirror/state";
+import { SELSchema } from "@seljs/schema";
+
+//#region src/completion/schema-completion.d.ts
+declare class SchemaCompletionProvider {
+  private topLevelCompletions;
+  private allDotCompletions;
+  private checker;
+  constructor(schema: SELSchema, checker: SELChecker);
+  completionSource: (context: CompletionContext) => CompletionResult | null;
+  private handleDotAccess;
+  private handleCallArg;
+  private handleTopLevel;
+  /**
+   * Use the checker to infer the expected type at cursor position
+   * and filter completions to only type-compatible items.
+   * Returns undefined when narrowing is not possible.
+   */
+  private narrowByExpectedType;
+}
+declare const createSchemaCompletion: (schema: SELSchema, checker: SELChecker) => Extension;
+//#endregion
+export { SchemaCompletionProvider, createSchemaCompletion };

package/dist/completion/schema-completion.mjs

@@ -0,0 +1,181 @@
+import { createContractCompletions, createFunctionCompletions, createMacroCompletions, createMethodCompletions, createVariableCompletions } from "./completion-items.mjs";
+import { getCompletionContext } from "./tree-context.mjs";
+import { autocompletion } from "@codemirror/autocomplete";
+import { isTypeCompatible } from "@seljs/checker";
+//#region src/completion/schema-completion.ts
+/**
+* Determine the CodeMirror completion type from a checker CompletionItem.
+* Method details start with "(" (e.g., "(owner: sol_address): sol_int"),
+* while struct field details are plain type names (e.g., "sol_int").
+*/
+const completionKind = (item) => item.detail?.startsWith("(") ? "method" : "property";
+var SchemaCompletionProvider = class {
+	topLevelCompletions;
+	allDotCompletions;
+	checker;
+	constructor(schema, checker) {
+		this.checker = checker;
+		const contractCompletions = createContractCompletions(schema.contracts);
+		const variableCompletions = createVariableCompletions(schema.variables);
+		const functionCompletions = createFunctionCompletions(schema.functions.filter((f) => !f.receiverType));
+		const macroCompletions = createMacroCompletions(schema.macros);
+		const atomCompletions = [
+			{
+				label: "true",
+				type: "keyword"
+			},
+			{
+				label: "false",
+				type: "keyword"
+			},
+			{
+				label: "null",
+				type: "keyword"
+			}
+		];
+		this.topLevelCompletions = [
+			...contractCompletions,
+			...variableCompletions,
+			...functionCompletions,
+			...atomCompletions
+		];
+		const allMethods = [];
+		for (const contract of schema.contracts) allMethods.push(...createMethodCompletions(contract));
+		const structFields = [];
+		for (const type of schema.types) if (type.kind === "struct" && type.fields) for (const field of type.fields) structFields.push({
+			label: field.name,
+			type: "property",
+			detail: field.type,
+			info: field.description
+		});
+		const receiverMethods = [];
+		for (const fn of schema.functions) if (fn.receiverType) receiverMethods.push({
+			label: fn.name,
+			type: "method",
+			detail: fn.signature,
+			info: fn.description
+		});
+		this.allDotCompletions = [
+			...allMethods,
+			...macroCompletions,
+			...structFields,
+			...receiverMethods
+		];
+	}
+	completionSource = (context) => {
+		const treeCtx = getCompletionContext(context.state, context.pos);
+		switch (treeCtx.kind) {
+			case "dot-access": return this.handleDotAccess(context, treeCtx);
+			case "call-arg": return this.handleCallArg(context, treeCtx);
+			case "top-level": return this.handleTopLevel(context, treeCtx);
+		}
+	};
+	handleDotAccess(context, treeCtx) {
+		const { receiverText, from } = treeCtx;
+		if (/^\d+$/.test(receiverText)) return this.handleTopLevel(context, {
+			kind: "top-level",
+			from
+		});
+		const info = this.checker.dotCompletions(receiverText);
+		if (info.items.length > 0) return {
+			from,
+			options: info.items.map((item) => ({
+				label: item.label,
+				type: completionKind(item),
+				detail: item.detail,
+				info: item.description
+			})),
+			filter: true
+		};
+		if (info.receiverType !== receiverText) return null;
+		return this.allDotCompletions.length ? {
+			from,
+			options: this.allDotCompletions,
+			filter: true
+		} : null;
+	}
+	handleCallArg(context, treeCtx) {
+		const expectedType = this.checker.expectedTypeFor({
+			kind: "function-arg",
+			functionName: treeCtx.functionName,
+			receiverName: treeCtx.receiverName,
+			paramIndex: treeCtx.paramIndex
+		});
+		if (expectedType) {
+			const filtered = this.topLevelCompletions.filter((c) => {
+				if (c.type === "keyword") {
+					if (c.label === "null") return true;
+					if (c.label === "true" || c.label === "false") return isTypeCompatible("bool", expectedType);
+				}
+				if (c.type === "variable" && c.detail) return isTypeCompatible(c.detail, expectedType);
+				if (c.type === "class" && c.label) return isTypeCompatible(`SEL_Contract_${c.label}`, expectedType);
+				return true;
+			});
+			if (filtered.length > 0) return {
+				from: context.matchBefore(/\w+/)?.from ?? treeCtx.from,
+				options: filtered,
+				filter: true
+			};
+		}
+		return this.handleTopLevel(context, {
+			kind: "top-level",
+			from: treeCtx.from
+		});
+	}
+	handleTopLevel(context, treeCtx) {
+		const wordMatch = context.matchBefore(/\w+/);
+		const from = wordMatch?.from ?? treeCtx.from;
+		const hasText = !!wordMatch;
+		const narrowed = this.narrowByExpectedType(context, from);
+		if (narrowed && narrowed.length > 0) return {
+			from,
+			options: narrowed,
+			filter: true
+		};
+		if (hasText) return this.topLevelCompletions.length ? {
+			from,
+			options: this.topLevelCompletions,
+			filter: true
+		} : null;
+		if (context.explicit && this.topLevelCompletions.length) return {
+			from: context.pos,
+			options: this.topLevelCompletions,
+			filter: true
+		};
+		return null;
+	}
+	/**
+	* Use the checker to infer the expected type at cursor position
+	* and filter completions to only type-compatible items.
+	* Returns undefined when narrowing is not possible.
+	*/
+	narrowByExpectedType(context, from) {
+		const doc = context.state.doc.toString();
+		const info = this.checker.completionsAt(doc, from);
+		if (!info.expectedType) return;
+		const expectedType = info.expectedType;
+		const filtered = info.items.filter((item) => isTypeCompatible(item.type, expectedType)).map((item) => ({
+			label: item.label,
+			type: item.type.startsWith("SEL_Contract_") ? "class" : item.detail ? "function" : "variable",
+			detail: item.detail ?? item.type,
+			info: item.description
+		}));
+		if (isTypeCompatible("bool", expectedType)) filtered.push({
+			label: "true",
+			type: "keyword"
+		}, {
+			label: "false",
+			type: "keyword"
+		});
+		filtered.push({
+			label: "null",
+			type: "keyword"
+		});
+		return filtered.length > 0 ? filtered : void 0;
+	}
+};
+const createSchemaCompletion = (schema, checker) => {
+	return autocompletion({ override: [new SchemaCompletionProvider(schema, checker).completionSource] });
+};
+//#endregion
+export { SchemaCompletionProvider, createSchemaCompletion };

package/dist/completion/tree-context.cjs

@@ -0,0 +1,108 @@
+let _codemirror_language = require("@codemirror/language");
+//#region src/completion/tree-context.ts
+/**
+* Walk up the tree looking for a MemberExpression ancestor.
+* A MemberExpression has two Identifier children (or child nodes) separated by ".".
+* The dot position is: firstChild.to + 1 (the "." character is between them).
+* We are in dot-access context when pos >= dotPos.
+*/
+const findDotAccess = (state, node, pos) => {
+	let current = node;
+	while (current) {
+		if (current.name === "ArgList") break;
+		if (current.name === "MemberExpression" || current.name === "OptionalExpression") {
+			const firstChild = current.firstChild;
+			if (firstChild) {
+				const dotPos = firstChild.to + 1;
+				if (pos >= dotPos) return {
+					kind: "dot-access",
+					receiverText: state.doc.sliceString(current.from, firstChild.to),
+					from: dotPos
+				};
+			}
+		}
+		current = current.parent;
+	}
+};
+/**
+* Count commas in ArgList text that appear before pos.
+* Commas are anonymous tokens not exposed as named children,
+* so we scan the raw source text.
+*/
+const countCommasBefore = (argList, state, pos) => {
+	const open = argList.from + 1;
+	const end = Math.min(pos, argList.to);
+	const text = state.doc.sliceString(open, end);
+	let count = 0;
+	for (const ch of text) if (ch === ",") count++;
+	return count;
+};
+/**
+* Extract function name and optional receiver name from a CallExpression node.
+*
+* Tree shapes:
+*   foo(...)          → CallExpression > Identifier, ArgList
+*   erc20.foo(...)    → CallExpression > MemberExpression(Identifier "erc20", Identifier "foo"), ArgList
+*/
+const extractCallInfo = (state, callExpr) => {
+	const callee = callExpr.firstChild;
+	if (!callee) return;
+	if (callee.name === "Identifier") return { functionName: state.doc.sliceString(callee.from, callee.to) };
+	if (callee.name === "MemberExpression") {
+		const lastChild = callee.lastChild;
+		if (lastChild?.name === "Identifier") {
+			const functionName = state.doc.sliceString(lastChild.from, lastChild.to);
+			const receiverNode = callee.firstChild;
+			return {
+				functionName,
+				receiverName: receiverNode?.name === "Identifier" ? state.doc.sliceString(receiverNode.from, receiverNode.to) : void 0
+			};
+		}
+	}
+};
+const findWordStart = (state, pos) => {
+	const text = state.doc.sliceString(0, pos);
+	const match = /\w+$/.exec(text);
+	return match ? pos - match[0].length : pos;
+};
+/**
+* Walk up the tree looking for an ArgList ancestor.
+* When found, count commas before pos to get paramIndex,
+* then extract function name and optional receiver from the CallExpression.
+*/
+const findCallArg = (state, node, pos) => {
+	let current = node;
+	while (current) {
+		if (current.name === "ArgList") {
+			const paramIndex = countCommasBefore(current, state, pos);
+			const callExpr = current.parent;
+			if (callExpr?.name === "CallExpression") {
+				const info = extractCallInfo(state, callExpr);
+				if (info) return {
+					kind: "call-arg",
+					functionName: info.functionName,
+					receiverName: info.receiverName,
+					paramIndex,
+					from: pos
+				};
+			}
+		}
+		current = current.parent;
+	}
+};
+/**
+* Extract completion context from the Lezer syntax tree at the given position.
+*/
+const getCompletionContext = (state, pos) => {
+	const node = (0, _codemirror_language.syntaxTree)(state).resolveInner(pos, -1);
+	const dotAccess = findDotAccess(state, node, pos);
+	if (dotAccess) return dotAccess;
+	const callArg = findCallArg(state, node, pos);
+	if (callArg) return callArg;
+	return {
+		kind: "top-level",
+		from: findWordStart(state, pos)
+	};
+};
+//#endregion
+exports.getCompletionContext = getCompletionContext;