@coldsmirk/inkstone-codemirror 0.8.2 → 0.9.0

package/dist/{minijinja-HpehSBbW.js → minijinja-D_5erBa7.js}

@@ -1,4 +1,4 @@
-import { i as resolveMembers, n as minijinjaContextField, o as typeAtPath, r as normalizeContext, t as elementType } from "./context-Dx6bPnKq.js";
+import { i as resolveMembers, n as minijinjaContextField, o as typeAtPath, r as normalizeContext, t as elementType } from "./context-D86o2jK3.js";
 import { LanguageSupport, syntaxTree } from "@codemirror/language";
 import { jinja, jinjaLanguage } from "@codemirror/lang-jinja";
 import { linter } from "@codemirror/lint";
@@ -219,51 +219,110 @@ function loopField(kind) {
 		nullable: false
 	};
 }
+const ROOT_SCOPE = -1;
 function scopeBindings(state, pos, ir) {
 	const bindings = /* @__PURE__ */ new Map();
-	for (let node = syntaxTree(state).resolveInner(pos, -1); node; node = node.parent) if (node.name === "ForStatement") collectForBindings(state, node, pos, ir, bindings);
-	else if (node.name === "MacroStatement") collectMacroBindings(state, node, pos, bindings);
-	collectSetBindings(state, pos, bindings);
+	const enclosing = [];
+	for (let node = syntaxTree(state).resolveInner(pos, -1); node; node = node.parent) if (node.name === "ForStatement" || node.name === "MacroStatement" || node.name === "WithStatement") enclosing.push(node);
+	const scopes = enclosing.toReversed();
+	const sets = collectSetBindings(state, pos, scopes);
+	const applySets = (scopeKey) => {
+		const definitions = sets.get(scopeKey) ?? [];
+		for (const definition of definitions) bindings.set(state.sliceDoc(definition.from, definition.to), { kind: "any" });
+	};
+	applySets(ROOT_SCOPE);
+	for (const node of scopes) {
+		if (node.name === "ForStatement") collectForBindings(state, node, pos, ir, bindings);
+		else if (node.name === "MacroStatement") collectMacroBindings(state, node, pos, bindings);
+		else collectWithBindings(state, node, pos, ir, bindings);
+		applySets(node.from);
+	}
 	return bindings;
 }
 function collectForBindings(state, forNode, pos, ir, bindings) {
 	const tag = forNode.firstChild;
-	if (!tag || tag.name !== "Tag" || pos < tag.to) return;
+	if (!tag || !tagBodyStarted(tag, pos)) return;
 	const definitions = [];
 	let iterable = null;
 	let seenIn = false;
 	for (let child = tag.firstChild; child; child = child.nextSibling) if (child.name === "in") seenIn = true;
 	else if (!seenIn && child.name === "Definition") definitions.push(child);
 	else if (seenIn && !iterable && child.name !== "%}") iterable = child;
-	if (!bindings.has("loop")) bindings.set("loop", LOOP_TYPE);
-	const [only] = definitions;
-	if (only && definitions.length === 1 && iterable) {
+	let element = null;
+	if (definitions.length === 1 && iterable) {
 		const path = walkBase(state, iterable);
-		const iterableType = path ? typeAtPath(ir, path) : null;
-		const element = iterableType ? elementType(ir, iterableType) : null;
-		bindings.set(state.sliceDoc(only.from, only.to), element ?? { kind: "any" });
-		return;
+		const iterableType = path ? typeAtPath(ir, path, bindings) : null;
+		element = iterableType ? elementType(ir, iterableType) : null;
+	}
+	bindings.set("loop", LOOP_TYPE);
+	for (const definition of definitions) bindings.set(state.sliceDoc(definition.from, definition.to), element ?? { kind: "any" });
+}
+function collectWithBindings(state, withNode, pos, ir, bindings) {
+	const tag = withNode.firstChild;
+	if (!tag || tag.name !== "Tag") return;
+	const inBody = tagBodyStarted(tag, pos);
+	let targets = [];
+	for (let child = tag.firstChild; child; child = child.nextSibling) {
+		if (child.name === "Definition") {
+			targets.push(child);
+			continue;
+		}
+		if (child.name !== "AssignOp" || targets.length === 0) continue;
+		const value = child.nextSibling;
+		const delimiter = value?.nextSibling;
+		if (inBody || delimiter?.name === "," && delimiter.to <= pos) {
+			const path = targets.length === 1 && value ? walkBase(state, value) : null;
+			const type = path ? typeAtPath(ir, path, bindings) : null;
+			for (const target of targets) bindings.set(state.sliceDoc(target.from, target.to), type ?? { kind: "any" });
+		}
+		targets = [];
 	}
-	for (const definition of definitions) bindings.set(state.sliceDoc(definition.from, definition.to), { kind: "any" });
 }
 function collectMacroBindings(state, macroNode, pos, bindings) {
 	const tag = macroNode.firstChild;
-	if (!tag || tag.name !== "Tag" || pos < tag.to) return;
+	if (!tag || !tagBodyStarted(tag, pos)) return;
 	const paramList = tag.getChild("ParamList");
 	if (!paramList) return;
 	for (let child = paramList.firstChild; child; child = child.nextSibling) if (child.name === "Definition") bindings.set(state.sliceDoc(child.from, child.to), { kind: "any" });
 }
-function collectSetBindings(state, pos, bindings) {
+function tagBodyStarted(tag, pos) {
+	return tag.name === "Tag" && tag.getChild("%}") !== null && pos >= tag.to;
+}
+function collectSetBindings(state, pos, scopes) {
+	const scopeStarts = new Set(scopes.map((scope) => scope.from));
+	const sets = /* @__PURE__ */ new Map();
 	syntaxTree(state).iterate({
 		to: pos,
 		enter: (node) => {
 			if (node.name !== "Tag" || node.to > pos) return;
 			const keyword = node.node.firstChild?.nextSibling;
 			if (!keyword || state.sliceDoc(keyword.from, keyword.to) !== "set") return;
-			const definition = keyword.nextSibling;
-			if (definition && definition.name === "Definition") bindings.set(state.sliceDoc(definition.from, definition.to), { kind: "any" });
+			const definitions = [];
+			let assignment = false;
+			for (let child = keyword.nextSibling; child; child = child.nextSibling) {
+				if (child.name === "AssignOp") {
+					assignment = true;
+					break;
+				}
+				if (child.name === "Definition") definitions.push(child);
+			}
+			if (definitions.length === 0) return;
+			const statement = node.node.parent;
+			if (assignment) {
+				if (!node.node.getChild("%}")) return;
+			} else if (statement?.name !== "SetStatement" || statement.to > pos || !statement.getChild("EndTag")) return;
+			let scopeKey = ROOT_SCOPE;
+			for (let { parent } = node.node; parent; parent = parent.parent) if (parent.name === "ForStatement" || parent.name === "MacroStatement" || parent.name === "WithStatement") {
+				if (!scopeStarts.has(parent.from)) return;
+				scopeKey = parent.from;
+				break;
+			}
+			const bucket = sets.get(scopeKey);
+			if (bucket) bucket.push(...definitions);
+			else sets.set(scopeKey, definitions);
 		}
 	});
+	return sets;
 }
 function jinjaContext(state, pos, side) {
 	for (let node = syntaxTree(state).resolveInner(pos, side); node; node = node.parent) {
@@ -279,7 +338,11 @@ function minijinjaCompletion(context) {
 	if (!word) return null;
 	const { from } = word;
 	const before = context.state.sliceDoc(Math.max(0, from - 24), from);
-	const side = from === context.pos ? 1 : -1;
+	let side = from === context.pos ? 1 : -1;
+	if (side === 1 && context.pos === context.state.doc.length) {
+		const left = syntaxTree(context.state).resolveInner(context.pos, -1);
+		if (left.name !== "}}" && left.name !== "%}" && left.name !== "#}") side = -1;
+	}
 	if (jinjaContext(context.state, context.pos, side) !== "expr") return null;
 	if (/\{%[-+]?\s*$/.test(before)) return {
 		from,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldsmirk/inkstone-codemirror",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "description": "Framework-agnostic CodeMirror 6 plumbing: a controlled editor host (create-once, external-value reconcile, in-place theme swap) and the standard document extension bundle.",
   "keywords": [
     "codemirror",
@@ -24,24 +24,17 @@
   "type": "module",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
     "dist"
   ],
   "dependencies": {
+    "@codemirror/lang-angular": "^0.1.4",
     "@codemirror/lang-cpp": "^6.0.3",
     "@codemirror/lang-css": "^6.3.1",
     "@codemirror/lang-go": "^6.0.1",
@@ -51,6 +44,7 @@
     "@codemirror/lang-jinja": "^6.0.1",
     "@codemirror/lang-json": "^6.0.2",
     "@codemirror/lang-less": "^6.0.2",
+    "@codemirror/lang-lezer": "^6.0.2",
     "@codemirror/lang-liquid": "^6.3.2",
     "@codemirror/lang-markdown": "^6.5.0",
     "@codemirror/lang-php": "^6.0.2",
@@ -62,6 +56,7 @@
     "@codemirror/lang-wast": "^6.0.2",
     "@codemirror/lang-xml": "^6.1.0",
     "@codemirror/lang-yaml": "^6.1.3",
+    "@codemirror/legacy-modes": "^6.5.3",
     "@codemirror/lint": "^6.9.7",
     "@lezer/common": "^1.5.2"
   },
@@ -82,7 +77,7 @@
     "@codemirror/view": "^6.43.0"
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=24"
   },
   "publishConfig": {
     "access": "public"

package/dist/context-BDibyUwD.cjs

@@ -1,270 +0,0 @@
-let _codemirror_state = require("@codemirror/state");
-//#region src/context.ts
-const ANY = { kind: "any" };
-const NULL = { kind: "null" };
-const MAX_DEREF = 100;
-const setMinijinjaContext = _codemirror_state.StateEffect.define();
-const minijinjaContextField = _codemirror_state.StateField.define({
-	create() {
-		return null;
-	},
-	update(value, transaction) {
-		let next = value;
-		for (const effect of transaction.effects) if (effect.is(setMinijinjaContext)) next = effect.value;
-		return next;
-	}
-});
-function normalizeContext(input) {
-	if ("schema" in input) return fromJsonSchema(input.schema);
-	return {
-		root: fromSample(input.sample),
-		defs: {}
-	};
-}
-function resolveMembers(ir, path, scope) {
-	const [first, ...rest] = path;
-	if (first === void 0) {
-		const top = membersOf(ir, ir.root);
-		if (!scope || scope.size === 0) return top;
-		return [...[...scope].map(([name, type]) => {
-			return {
-				name,
-				type,
-				required: true,
-				nullable: false
-			};
-		}), ...top];
-	}
-	let type = scope?.get(first) ?? stepInto(ir, ir.root, first);
-	for (const key of rest) {
-		if (!type) break;
-		type = stepInto(ir, type, key);
-	}
-	return type ? membersOf(ir, type) : [];
-}
-function typeAtPath(ir, path) {
-	let type = ir.root;
-	for (const key of path) {
-		const next = stepInto(ir, type, key);
-		if (next === null) return null;
-		type = next;
-	}
-	return deref(ir, type);
-}
-function elementType(ir, type) {
-	const resolved = deref(ir, type);
-	return resolved.kind === "array" ? deref(ir, resolved.element) : null;
-}
-function deref(ir, type) {
-	let current = type;
-	for (let i = 0; i < MAX_DEREF && current.kind === "ref"; i++) {
-		const next = ir.defs[current.name];
-		if (!next) return ANY;
-		current = next;
-	}
-	return current;
-}
-function stepInto(ir, type, key) {
-	const resolved = deref(ir, type);
-	if (resolved.kind !== "object") return null;
-	const field = resolved.fields[key];
-	return field ? field.type : null;
-}
-function membersOf(ir, type) {
-	const resolved = deref(ir, type);
-	if (resolved.kind !== "object") return [];
-	return Object.entries(resolved.fields).map(([name, field]) => {
-		return {
-			name,
-			type: field.type,
-			required: field.required,
-			nullable: field.nullable,
-			doc: field.doc
-		};
-	});
-}
-const REF_PREFIXES = ["#/$defs/", "#/definitions/"];
-function fromJsonSchema(schema) {
-	if (!isObject(schema)) return {
-		root: ANY,
-		defs: {}
-	};
-	const defsSource = {
-		...asObject(schema.definitions),
-		...asObject(schema.$defs)
-	};
-	const defs = {};
-	for (const [name, sub] of Object.entries(defsSource)) defs[name] = convert(sub);
-	return {
-		root: convert(schema),
-		defs
-	};
-}
-function convert(node) {
-	if (typeof node === "boolean" || !isObject(node)) return ANY;
-	const ref = refName(node.$ref);
-	if (ref !== null) return {
-		kind: "ref",
-		name: ref
-	};
-	if (Array.isArray(node.allOf)) return mergeAll(node.allOf.map((entry) => convert(entry)));
-	const union = node.anyOf ?? node.oneOf;
-	if (Array.isArray(union)) {
-		const nonNull = union.filter((branch) => !isNullBranch(branch));
-		if (nonNull.length === 0) return NULL;
-		return nonNull.length === 1 ? convert(nonNull[0]) : mergeAll(nonNull.map((entry) => convert(entry)));
-	}
-	if (Array.isArray(node.enum)) return {
-		kind: "enum",
-		values: node.enum.filter(isLiteral)
-	};
-	if ("const" in node && isLiteral(node.const)) return {
-		kind: "enum",
-		values: [node.const]
-	};
-	const type = primaryType(node);
-	if (type === "object" || isObject(node.properties)) return objectType(node);
-	if (type === "array") return {
-		kind: "array",
-		element: convert(Array.isArray(node.items) ? node.items[0] : node.items)
-	};
-	if (type === "string") return { kind: "string" };
-	if (type === "integer" || type === "number") return { kind: "number" };
-	if (type === "boolean") return { kind: "boolean" };
-	if (type === "null") return NULL;
-	return ANY;
-}
-function objectType(node) {
-	const properties = asObject(node.properties);
-	const required = new Set(Array.isArray(node.required) ? node.required.filter((name) => typeof name === "string") : []);
-	const fields = {};
-	for (const [name, sub] of Object.entries(properties)) fields[name] = {
-		type: convert(sub),
-		required: required.has(name),
-		nullable: isNullable(sub),
-		doc: description(sub)
-	};
-	return {
-		kind: "object",
-		fields
-	};
-}
-function mergeAll(types) {
-	const objects = types.filter((type) => type.kind === "object");
-	if (objects.length > 0) {
-		const fields = {};
-		for (const object of objects) Object.assign(fields, object.fields);
-		return {
-			kind: "object",
-			fields
-		};
-	}
-	return types.find((type) => type.kind !== "any") ?? ANY;
-}
-function fromSample(value, ancestors = /* @__PURE__ */ new WeakSet()) {
-	if (value === null || value === void 0) return ANY;
-	if (typeof value === "object") {
-		if (ancestors.has(value)) return ANY;
-		ancestors.add(value);
-		const type = Array.isArray(value) ? sampleArrayType(value, ancestors) : sampleObjectType(value, ancestors);
-		ancestors.delete(value);
-		return type;
-	}
-	if (typeof value === "string") return { kind: "string" };
-	if (typeof value === "number") return { kind: "number" };
-	if (typeof value === "boolean") return { kind: "boolean" };
-	return ANY;
-}
-function sampleArrayType(value, ancestors) {
-	return {
-		kind: "array",
-		element: value.length > 0 ? fromSample(value[0], ancestors) : ANY
-	};
-}
-function sampleObjectType(value, ancestors) {
-	const fields = {};
-	for (const [name, member] of Object.entries(value)) fields[name] = {
-		type: fromSample(member, ancestors),
-		required: true,
-		nullable: member === null
-	};
-	return {
-		kind: "object",
-		fields
-	};
-}
-function refName(ref) {
-	if (typeof ref !== "string") return null;
-	for (const prefix of REF_PREFIXES) if (ref.startsWith(prefix)) return decodeURIComponent(ref.slice(prefix.length));
-	return null;
-}
-function primaryType(node) {
-	const { type } = node;
-	if (typeof type === "string") return type;
-	if (Array.isArray(type)) {
-		const nonNull = type.find((entry) => typeof entry === "string" && entry !== "null");
-		if (typeof nonNull === "string") return nonNull;
-		return type.includes("null") ? "null" : null;
-	}
-	return null;
-}
-function isNullable(node) {
-	if (!isObject(node)) return false;
-	const { type } = node;
-	if (type === "null" || Array.isArray(type) && type.includes("null")) return true;
-	const union = node.anyOf ?? node.oneOf;
-	return Array.isArray(union) && union.some((branch) => isNullBranch(branch));
-}
-function isNullBranch(branch) {
-	if (!isObject(branch)) return false;
-	return branch.type === "null" || Array.isArray(branch.type) && branch.type.length === 1 && branch.type[0] === "null";
-}
-function description(node) {
-	return isObject(node) && typeof node.description === "string" ? node.description : void 0;
-}
-function isObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function asObject(value) {
-	return isObject(value) ? value : {};
-}
-function isLiteral(value) {
-	return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-}
-//#endregion
-Object.defineProperty(exports, "elementType", {
-	enumerable: true,
-	get: function() {
-		return elementType;
-	}
-});
-Object.defineProperty(exports, "minijinjaContextField", {
-	enumerable: true,
-	get: function() {
-		return minijinjaContextField;
-	}
-});
-Object.defineProperty(exports, "normalizeContext", {
-	enumerable: true,
-	get: function() {
-		return normalizeContext;
-	}
-});
-Object.defineProperty(exports, "resolveMembers", {
-	enumerable: true,
-	get: function() {
-		return resolveMembers;
-	}
-});
-Object.defineProperty(exports, "setMinijinjaContext", {
-	enumerable: true,
-	get: function() {
-		return setMinijinjaContext;
-	}
-});
-Object.defineProperty(exports, "typeAtPath", {
-	enumerable: true,
-	get: function() {
-		return typeAtPath;
-	}
-});