@coldsmirk/inkstone-codemirror 0.9.0 → 0.10.1

package/dist/sql-schema-DiPx5-bu.js

@@ -0,0 +1,15 @@
+import { StateEffect, StateField } from "@codemirror/state";
+//#region src/sql-schema.ts
+const setSqlSchema = StateEffect.define();
+const sqlSchemaField = StateField.define({
+	create() {
+		return null;
+	},
+	update(value, transaction) {
+		let next = value;
+		for (const effect of transaction.effects) if (effect.is(setSqlSchema)) next = effect.value;
+		return next;
+	}
+});
+//#endregion
+export { sqlSchemaField as n, setSqlSchema as t };

package/dist/sql-support-Gk7Wv9Kj.js

@@ -0,0 +1,29 @@
+import { n as sqlSchemaField } from "./sql-schema-DiPx5-bu.js";
+import { LanguageSupport } from "@codemirror/language";
+import { schemaCompletionSource } from "@codemirror/lang-sql";
+//#region src/sql-support.ts
+function withSqlSchema(base, dialect) {
+	const delegates = /* @__PURE__ */ new WeakMap();
+	const source = (context) => {
+		const schema = context.state.field(sqlSchemaField, false) ?? null;
+		if (schema === null) return null;
+		let delegate = delegates.get(schema);
+		if (delegate === void 0) {
+			delegate = schemaCompletionSource({
+				dialect,
+				schema: schema.tables,
+				defaultTable: schema.defaultTable,
+				defaultSchema: schema.defaultSchema
+			});
+			delegates.set(schema, delegate);
+		}
+		return delegate(context);
+	};
+	return new LanguageSupport(base.language, [
+		base.support,
+		sqlSchemaField,
+		base.language.data.of({ autocomplete: source })
+	]);
+}
+//#endregion
+export { withSqlSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldsmirk/inkstone-codemirror",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "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",
@@ -58,6 +58,7 @@
     "@codemirror/lang-yaml": "^6.1.3",
     "@codemirror/legacy-modes": "^6.5.3",
     "@codemirror/lint": "^6.9.7",
+    "@codemirror/merge": "^6.12.2",
     "@lezer/common": "^1.5.2"
   },
   "devDependencies": {

package/dist/minijinja-D_5erBa7.js

@@ -1,418 +0,0 @@
-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";
-//#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
-	};
-}
-const ROOT_SCOPE = -1;
-function scopeBindings(state, pos, ir) {
-	const bindings = /* @__PURE__ */ new Map();
-	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 || !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;
-	let element = null;
-	if (definitions.length === 1 && iterable) {
-		const path = walkBase(state, iterable);
-		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 = [];
-	}
-}
-function collectMacroBindings(state, macroNode, pos, bindings) {
-	const tag = macroNode.firstChild;
-	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 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 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) {
-		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);
-	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,
-		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 };