@coldsmirk/inkstone-codemirror 0.8.2

package/dist/minijinja-DN9iLNbL.cjs

@@ -0,0 +1,357 @@
+const require_context = require("./context-BDibyUwD.cjs");
+let _codemirror_language = require("@codemirror/language");
+let _codemirror_lang_jinja = require("@codemirror/lang-jinja");
+let _codemirror_lint = require("@codemirror/lint");
+//#region src/minijinja.ts
+const MINIJINJA_TAGS = /* @__PURE__ */ new Set([
+	"autoescape",
+	"endautoescape",
+	"block",
+	"endblock",
+	"call",
+	"endcall",
+	"filter",
+	"endfilter",
+	"for",
+	"endfor",
+	"if",
+	"elif",
+	"else",
+	"endif",
+	"macro",
+	"endmacro",
+	"set",
+	"endset",
+	"with",
+	"endwith",
+	"raw",
+	"endraw",
+	"extends",
+	"include",
+	"import",
+	"from",
+	"do",
+	"break",
+	"continue"
+]);
+const MINIJINJA_FILTERS = [
+	"abs",
+	"attr",
+	"batch",
+	"bool",
+	"capitalize",
+	"chain",
+	"count",
+	"d",
+	"default",
+	"dictsort",
+	"e",
+	"escape",
+	"first",
+	"float",
+	"format",
+	"groupby",
+	"indent",
+	"int",
+	"items",
+	"join",
+	"last",
+	"length",
+	"lines",
+	"list",
+	"lower",
+	"map",
+	"max",
+	"min",
+	"pprint",
+	"reject",
+	"rejectattr",
+	"replace",
+	"reverse",
+	"round",
+	"safe",
+	"select",
+	"selectattr",
+	"slice",
+	"sort",
+	"split",
+	"string",
+	"sum",
+	"title",
+	"tojson",
+	"trim",
+	"unique",
+	"upper",
+	"urlencode",
+	"zip"
+];
+const MINIJINJA_TESTS = [
+	"boolean",
+	"defined",
+	"divisibleby",
+	"endingwith",
+	"eq",
+	"equalto",
+	"escaped",
+	"even",
+	"false",
+	"filter",
+	"float",
+	"ge",
+	"greaterthan",
+	"in",
+	"int",
+	"integer",
+	"iterable",
+	"le",
+	"lessthan",
+	"lower",
+	"lt",
+	"gt",
+	"mapping",
+	"ne",
+	"none",
+	"number",
+	"odd",
+	"safe",
+	"sameas",
+	"sequence",
+	"startingwith",
+	"string",
+	"test",
+	"true",
+	"undefined",
+	"upper"
+];
+const MINIJINJA_FUNCTIONS = [
+	"debug",
+	"dict",
+	"namespace",
+	"range"
+];
+function toCompletions(labels, type) {
+	return [...labels].toSorted().map((label) => {
+		return {
+			label,
+			type
+		};
+	});
+}
+const tagCompletions = toCompletions(MINIJINJA_TAGS, "keyword");
+const filterCompletions = toCompletions(MINIJINJA_FILTERS, "function");
+const testCompletions = toCompletions(MINIJINJA_TESTS, "function");
+const functionCompletions = toCompletions(MINIJINJA_FUNCTIONS, "function");
+function memberCompletions(members, type) {
+	return members.map((member) => {
+		return {
+			label: member.name,
+			type,
+			detail: `${irTypeToString(member.type)}${member.nullable ? "?" : ""}`,
+			info: member.doc
+		};
+	});
+}
+function irTypeToString(type) {
+	switch (type.kind) {
+		case "object": return "object";
+		case "array": return `${irTypeToString(type.element)}[]`;
+		case "enum": return type.values.map((value) => typeof value === "string" ? `"${value}"` : String(value)).join(" | ");
+		case "ref": return type.name;
+		default: return type.kind;
+	}
+}
+function walkBase(state, node) {
+	if (!node) return null;
+	if (node.name === "VariableName" || node.name === "loop") return [state.sliceDoc(node.from, node.to)];
+	if (node.name === "MemberExpression") {
+		const inner = walkBase(state, node.firstChild);
+		const property = node.lastChild;
+		if (inner === null || !property || property.name !== "PropertyName") return null;
+		return [...inner, state.sliceDoc(property.from, property.to)];
+	}
+	return null;
+}
+function contextTarget(state, pos) {
+	const node = (0, _codemirror_language.syntaxTree)(state).resolveInner(pos, -1);
+	if (node.name === "PropertyName" && node.parent?.name === "MemberExpression") {
+		const path = walkBase(state, node.parent.firstChild);
+		return path ? {
+			path,
+			from: node.from
+		} : null;
+	}
+	if (node.name === "." && node.parent?.name === "MemberExpression") {
+		const path = walkBase(state, node.parent.firstChild);
+		return path ? {
+			path,
+			from: pos
+		} : null;
+	}
+	if (node.name === "Definition") return null;
+	const word = state.wordAt(pos);
+	return {
+		path: [],
+		from: word ? word.from : pos
+	};
+}
+const LOOP_TYPE = {
+	kind: "object",
+	fields: {
+		index: loopField("number"),
+		index0: loopField("number"),
+		revindex: loopField("number"),
+		revindex0: loopField("number"),
+		first: loopField("boolean"),
+		last: loopField("boolean"),
+		length: loopField("number"),
+		depth: loopField("number"),
+		depth0: loopField("number"),
+		previtem: loopField("any"),
+		nextitem: loopField("any"),
+		cycle: loopField("any"),
+		changed: loopField("any")
+	}
+};
+function loopField(kind) {
+	return {
+		type: { kind },
+		required: true,
+		nullable: false
+	};
+}
+function scopeBindings(state, pos, ir) {
+	const bindings = /* @__PURE__ */ new Map();
+	for (let node = (0, _codemirror_language.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);
+	return bindings;
+}
+function collectForBindings(state, forNode, pos, ir, bindings) {
+	const tag = forNode.firstChild;
+	if (!tag || tag.name !== "Tag" || pos < tag.to) 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) {
+		const path = walkBase(state, iterable);
+		const iterableType = path ? require_context.typeAtPath(ir, path) : null;
+		const element = iterableType ? require_context.elementType(ir, iterableType) : null;
+		bindings.set(state.sliceDoc(only.from, only.to), element ?? { kind: "any" });
+		return;
+	}
+	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;
+	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) {
+	(0, _codemirror_language.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" });
+		}
+	});
+}
+function jinjaContext(state, pos, side) {
+	for (let node = (0, _codemirror_language.syntaxTree)(state).resolveInner(pos, side); node; node = node.parent) {
+		const { name } = node;
+		if (name === "Comment") return "comment";
+		if (name === "StringLiteral" || name === "NumberLiteral") return null;
+		if (name === "Interpolation" || name === "Tag" || name === "EndTag") return "expr";
+	}
+	return null;
+}
+function minijinjaCompletion(context) {
+	const word = context.matchBefore(/\w*/);
+	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;
+	if (jinjaContext(context.state, context.pos, side) !== "expr") return null;
+	if (/\{%[-+]?\s*$/.test(before)) return {
+		from,
+		options: tagCompletions,
+		validFor: /^\w*$/
+	};
+	if (/\|\s*$/.test(before)) return {
+		from,
+		options: filterCompletions,
+		validFor: /^\w*$/
+	};
+	if (/\bis\s+(?:not\s+)?$/.test(before)) return {
+		from,
+		options: testCompletions,
+		validFor: /^\w*$/
+	};
+	const ir = context.state.field(require_context.minijinjaContextField, false);
+	if (ir) {
+		const target = contextTarget(context.state, context.pos);
+		if (!target) return null;
+		const scope = scopeBindings(context.state, context.pos, ir);
+		const members = require_context.resolveMembers(ir, target.path, scope);
+		if (target.path.length > 0) return members.length > 0 ? {
+			from: target.from,
+			options: memberCompletions(members, "property"),
+			validFor: /^\w*$/
+		} : null;
+		if (target.from === context.pos && !context.explicit) return null;
+		return {
+			from: target.from,
+			options: [...memberCompletions(members, "variable"), ...functionCompletions],
+			validFor: /^\w*$/
+		};
+	}
+	if (from === context.pos && !context.explicit) return null;
+	return {
+		from,
+		options: functionCompletions,
+		validFor: /^\w*$/
+	};
+}
+function minijinjaDiagnostics(state) {
+	const diagnostics = [];
+	const { doc } = state;
+	(0, _codemirror_language.syntaxTree)(state).iterate({ enter: (node) => {
+		if (node.name !== "Tag" && node.name !== "EndTag") return;
+		const keywordNode = node.node.firstChild?.nextSibling;
+		if (!keywordNode || keywordNode.type.isError) return;
+		const keyword = doc.sliceString(keywordNode.from, keywordNode.to);
+		if (!MINIJINJA_TAGS.has(keyword)) diagnostics.push({
+			from: keywordNode.from,
+			to: keywordNode.to,
+			severity: "error",
+			message: `"${keyword}" is not a MiniJinja tag.`
+		});
+	} });
+	return diagnostics;
+}
+const minijinjaLinter = (0, _codemirror_lint.linter)((view) => minijinjaDiagnostics(view.state));
+function minijinja(config = {}) {
+	const { base, context } = config;
+	const language = base ? (0, _codemirror_lang_jinja.jinja)({ base }).language : _codemirror_lang_jinja.jinjaLanguage;
+	const contextField = context ? require_context.minijinjaContextField.init(() => require_context.normalizeContext(context)) : require_context.minijinjaContextField;
+	const support = [
+		language.data.of({ autocomplete: minijinjaCompletion }),
+		minijinjaLinter,
+		contextField
+	];
+	if (base) support.push(base.support);
+	return new _codemirror_language.LanguageSupport(language, support);
+}
+//#endregion
+exports.minijinja = minijinja;
+exports.minijinjaCompletion = minijinjaCompletion;
+exports.minijinjaDiagnostics = minijinjaDiagnostics;

package/dist/minijinja-HpehSBbW.js

@@ -0,0 +1,355 @@
+import { i as resolveMembers, n as minijinjaContextField, o as typeAtPath, r as normalizeContext, t as elementType } from "./context-Dx6bPnKq.js";
+import { LanguageSupport, syntaxTree } from "@codemirror/language";
+import { jinja, jinjaLanguage } from "@codemirror/lang-jinja";
+import { linter } from "@codemirror/lint";
+//#region src/minijinja.ts
+const MINIJINJA_TAGS = /* @__PURE__ */ new Set([
+	"autoescape",
+	"endautoescape",
+	"block",
+	"endblock",
+	"call",
+	"endcall",
+	"filter",
+	"endfilter",
+	"for",
+	"endfor",
+	"if",
+	"elif",
+	"else",
+	"endif",
+	"macro",
+	"endmacro",
+	"set",
+	"endset",
+	"with",
+	"endwith",
+	"raw",
+	"endraw",
+	"extends",
+	"include",
+	"import",
+	"from",
+	"do",
+	"break",
+	"continue"
+]);
+const MINIJINJA_FILTERS = [
+	"abs",
+	"attr",
+	"batch",
+	"bool",
+	"capitalize",
+	"chain",
+	"count",
+	"d",
+	"default",
+	"dictsort",
+	"e",
+	"escape",
+	"first",
+	"float",
+	"format",
+	"groupby",
+	"indent",
+	"int",
+	"items",
+	"join",
+	"last",
+	"length",
+	"lines",
+	"list",
+	"lower",
+	"map",
+	"max",
+	"min",
+	"pprint",
+	"reject",
+	"rejectattr",
+	"replace",
+	"reverse",
+	"round",
+	"safe",
+	"select",
+	"selectattr",
+	"slice",
+	"sort",
+	"split",
+	"string",
+	"sum",
+	"title",
+	"tojson",
+	"trim",
+	"unique",
+	"upper",
+	"urlencode",
+	"zip"
+];
+const MINIJINJA_TESTS = [
+	"boolean",
+	"defined",
+	"divisibleby",
+	"endingwith",
+	"eq",
+	"equalto",
+	"escaped",
+	"even",
+	"false",
+	"filter",
+	"float",
+	"ge",
+	"greaterthan",
+	"in",
+	"int",
+	"integer",
+	"iterable",
+	"le",
+	"lessthan",
+	"lower",
+	"lt",
+	"gt",
+	"mapping",
+	"ne",
+	"none",
+	"number",
+	"odd",
+	"safe",
+	"sameas",
+	"sequence",
+	"startingwith",
+	"string",
+	"test",
+	"true",
+	"undefined",
+	"upper"
+];
+const MINIJINJA_FUNCTIONS = [
+	"debug",
+	"dict",
+	"namespace",
+	"range"
+];
+function toCompletions(labels, type) {
+	return [...labels].toSorted().map((label) => {
+		return {
+			label,
+			type
+		};
+	});
+}
+const tagCompletions = toCompletions(MINIJINJA_TAGS, "keyword");
+const filterCompletions = toCompletions(MINIJINJA_FILTERS, "function");
+const testCompletions = toCompletions(MINIJINJA_TESTS, "function");
+const functionCompletions = toCompletions(MINIJINJA_FUNCTIONS, "function");
+function memberCompletions(members, type) {
+	return members.map((member) => {
+		return {
+			label: member.name,
+			type,
+			detail: `${irTypeToString(member.type)}${member.nullable ? "?" : ""}`,
+			info: member.doc
+		};
+	});
+}
+function irTypeToString(type) {
+	switch (type.kind) {
+		case "object": return "object";
+		case "array": return `${irTypeToString(type.element)}[]`;
+		case "enum": return type.values.map((value) => typeof value === "string" ? `"${value}"` : String(value)).join(" | ");
+		case "ref": return type.name;
+		default: return type.kind;
+	}
+}
+function walkBase(state, node) {
+	if (!node) return null;
+	if (node.name === "VariableName" || node.name === "loop") return [state.sliceDoc(node.from, node.to)];
+	if (node.name === "MemberExpression") {
+		const inner = walkBase(state, node.firstChild);
+		const property = node.lastChild;
+		if (inner === null || !property || property.name !== "PropertyName") return null;
+		return [...inner, state.sliceDoc(property.from, property.to)];
+	}
+	return null;
+}
+function contextTarget(state, pos) {
+	const node = syntaxTree(state).resolveInner(pos, -1);
+	if (node.name === "PropertyName" && node.parent?.name === "MemberExpression") {
+		const path = walkBase(state, node.parent.firstChild);
+		return path ? {
+			path,
+			from: node.from
+		} : null;
+	}
+	if (node.name === "." && node.parent?.name === "MemberExpression") {
+		const path = walkBase(state, node.parent.firstChild);
+		return path ? {
+			path,
+			from: pos
+		} : null;
+	}
+	if (node.name === "Definition") return null;
+	const word = state.wordAt(pos);
+	return {
+		path: [],
+		from: word ? word.from : pos
+	};
+}
+const LOOP_TYPE = {
+	kind: "object",
+	fields: {
+		index: loopField("number"),
+		index0: loopField("number"),
+		revindex: loopField("number"),
+		revindex0: loopField("number"),
+		first: loopField("boolean"),
+		last: loopField("boolean"),
+		length: loopField("number"),
+		depth: loopField("number"),
+		depth0: loopField("number"),
+		previtem: loopField("any"),
+		nextitem: loopField("any"),
+		cycle: loopField("any"),
+		changed: loopField("any")
+	}
+};
+function loopField(kind) {
+	return {
+		type: { kind },
+		required: true,
+		nullable: false
+	};
+}
+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);
+	return bindings;
+}
+function collectForBindings(state, forNode, pos, ir, bindings) {
+	const tag = forNode.firstChild;
+	if (!tag || tag.name !== "Tag" || pos < tag.to) 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) {
+		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;
+	}
+	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;
+	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) {
+	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" });
+		}
+	});
+}
+function jinjaContext(state, pos, side) {
+	for (let node = syntaxTree(state).resolveInner(pos, side); node; node = node.parent) {
+		const { name } = node;
+		if (name === "Comment") return "comment";
+		if (name === "StringLiteral" || name === "NumberLiteral") return null;
+		if (name === "Interpolation" || name === "Tag" || name === "EndTag") return "expr";
+	}
+	return null;
+}
+function minijinjaCompletion(context) {
+	const word = context.matchBefore(/\w*/);
+	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;
+	if (jinjaContext(context.state, context.pos, side) !== "expr") return null;
+	if (/\{%[-+]?\s*$/.test(before)) return {
+		from,
+		options: tagCompletions,
+		validFor: /^\w*$/
+	};
+	if (/\|\s*$/.test(before)) return {
+		from,
+		options: filterCompletions,
+		validFor: /^\w*$/
+	};
+	if (/\bis\s+(?:not\s+)?$/.test(before)) return {
+		from,
+		options: testCompletions,
+		validFor: /^\w*$/
+	};
+	const ir = context.state.field(minijinjaContextField, false);
+	if (ir) {
+		const target = contextTarget(context.state, context.pos);
+		if (!target) return null;
+		const scope = scopeBindings(context.state, context.pos, ir);
+		const members = resolveMembers(ir, target.path, scope);
+		if (target.path.length > 0) return members.length > 0 ? {
+			from: target.from,
+			options: memberCompletions(members, "property"),
+			validFor: /^\w*$/
+		} : null;
+		if (target.from === context.pos && !context.explicit) return null;
+		return {
+			from: target.from,
+			options: [...memberCompletions(members, "variable"), ...functionCompletions],
+			validFor: /^\w*$/
+		};
+	}
+	if (from === context.pos && !context.explicit) return null;
+	return {
+		from,
+		options: functionCompletions,
+		validFor: /^\w*$/
+	};
+}
+function minijinjaDiagnostics(state) {
+	const diagnostics = [];
+	const { doc } = state;
+	syntaxTree(state).iterate({ enter: (node) => {
+		if (node.name !== "Tag" && node.name !== "EndTag") return;
+		const keywordNode = node.node.firstChild?.nextSibling;
+		if (!keywordNode || keywordNode.type.isError) return;
+		const keyword = doc.sliceString(keywordNode.from, keywordNode.to);
+		if (!MINIJINJA_TAGS.has(keyword)) diagnostics.push({
+			from: keywordNode.from,
+			to: keywordNode.to,
+			severity: "error",
+			message: `"${keyword}" is not a MiniJinja tag.`
+		});
+	} });
+	return diagnostics;
+}
+const minijinjaLinter = linter((view) => minijinjaDiagnostics(view.state));
+function minijinja(config = {}) {
+	const { base, context } = config;
+	const language = base ? jinja({ base }).language : jinjaLanguage;
+	const contextField = context ? minijinjaContextField.init(() => normalizeContext(context)) : minijinjaContextField;
+	const support = [
+		language.data.of({ autocomplete: minijinjaCompletion }),
+		minijinjaLinter,
+		contextField
+	];
+	if (base) support.push(base.support);
+	return new LanguageSupport(language, support);
+}
+//#endregion
+export { minijinja, minijinjaCompletion, minijinjaDiagnostics };