@coldsmirk/inkstone-codemirror 0.8.2 → 0.9.0

package/README.md

@@ -8,8 +8,8 @@ Part of [inkstone](https://github.com/coldsmirk/inkstone). For a drop-in React c
 
 - **`ControlledEditorHost`** — the controlled-editor lifecycle solved once: the view is created once, external value changes reconcile into the document without resetting cursor/undo, and theme/extension swaps happen in place.
 - **`documentExtensions(options)`** — the standard document editing bundle (history, brackets, completion UI, optional line numbers / wrapping / search), so hosts start from working defaults instead of a bare `EditorState`.
-- **`codeMirrorLanguages` / `loadLanguage(language)`** — the supported `CodeMirrorLanguage` names and their lazy loaders: one dynamic `import()` per grammar, so only the selected language is fetched, never the whole catalog.
-- **MiniJinja** — `language: "minijinja"` for standalone templates, or `minijinja-<host>` mixed variants (`minijinja-html`, `-xml`, `-json`, `-yaml`, `-css`, `-scss`, `-sass`, `-less`, `-markdown`, `-sql`, `-mysql`, `-pgsql`, `-sqlite`) that overlay MiniJinja tooling on the host grammar. A linter flags non-MiniJinja tags; autocomplete is restricted to MiniJinja's real tags / filters / tests / functions.
+- **`codeMirrorLanguages` / `loadLanguage(language)`** — the supported `CodeMirrorLanguage` names and their lazy loaders: one dynamic `import()` per grammar, so only the selected language is fetched, never the whole catalog. Two tiers back the ids: the official `@codemirror/lang-*` (Lezer) parsers where upstream ships one, plus the full [`@codemirror/legacy-modes`](https://github.com/codemirror/legacy-modes) catalog (stream-mode highlighting) for everything upstream never wrote a Lezer grammar for — `shell`, `dockerfile`, `ini` / `env` / `properties`, `toml`, `nginx`, `powershell`, `lua`, and a hundred more.
+- **MiniJinja** — `language: "minijinja"` for standalone templates, or `minijinja-<host>` mixed variants (`minijinja-html`, `-xml`, `-json`, `-yaml`, `-css`, `-scss`, `-sass`, `-less`, `-markdown`; the SQL family — `-sql` plus every dialect id: `-mysql`, `-pgsql`, `-sqlite`, `-mssql`, `-mariadb`, `-plsql`, `-cassandra`, `-hive`, `-sparksql`, `-gql`, `-gpsql`, `-esper`; and the config/deploy hosts `-toml`, `-ini`, `-env`, `-shell`, `-dockerfile`, `-nginx`) that overlay MiniJinja tooling on the host grammar. A linter flags non-MiniJinja tags; autocomplete is restricted to MiniJinja's real tags / filters / tests / functions.
 - **Context completion** — `normalizeContext({ schema })` (JSON Schema) or `normalizeContext({ sample })` (representative value) builds an `EditorContext`; dispatch it with `setMinijinjaContext` to make `{{ }}` / `{% if %}` / `{% for %}` complete the render context's variables and walk member access (`user.address.city`). `minijinjaContextField`, `resolveMembers`, and `typeAtPath` expose the underlying pieces.
 - **`searchPhrasesZhCn`** — an opt-in `EditorState.phrases` table localizing the search panel to Simplified Chinese.
 

package/dist/context-D86o2jK3.js

@@ -0,0 +1,382 @@
+import { StateEffect, StateField } from "@codemirror/state";
+//#region src/context.ts
+const ANY = { kind: "any" };
+const NULL = { kind: "null" };
+const MAX_DEREF = 100;
+const setMinijinjaContext = StateEffect.define();
+const minijinjaContextField = 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) {
+	if (path.length === 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];
+	}
+	const type = typeAtPath(ir, path, scope);
+	return type ? membersOf(ir, type) : [];
+}
+function typeAtPath(ir, path, scope) {
+	const [first, ...rest] = path;
+	if (first === void 0) return deref(ir, ir.root);
+	let type = scope?.get(first) ?? stepInto(ir, ir.root, first);
+	for (const key of rest) {
+		if (type === null) return null;
+		type = stepInto(ir, type, key);
+	}
+	return type === null ? null : deref(ir, type);
+}
+function elementType(ir, type) {
+	const resolved = deref(ir, type);
+	return resolved.kind === "array" ? deref(ir, resolved.element) : null;
+}
+function followRefs(type, lookup) {
+	let current = type;
+	for (let i = 0; i < MAX_DEREF && current.kind === "ref"; i++) {
+		const next = lookup(current.name);
+		if (!next) return null;
+		current = next;
+	}
+	return current.kind === "ref" ? null : current;
+}
+function deref(ir, type) {
+	return followRefs(type, (name) => ir.defs[name] ?? null) ?? ANY;
+}
+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 context = {
+		raw: {
+			...asObject(schema.definitions),
+			...asObject(schema.$defs)
+		},
+		defs: Object.create(null),
+		resolving: /* @__PURE__ */ new Set(),
+		tainted: /* @__PURE__ */ new Set(),
+		cyclic: /* @__PURE__ */ new Set(),
+		dependents: /* @__PURE__ */ new Map(),
+		converting: []
+	};
+	for (const name of Object.keys(context.raw)) defType(name, context);
+	if (context.tainted.size > 0) {
+		const queue = [...context.tainted];
+		const pending = new Set(queue);
+		let head = 0;
+		let budget = (Object.keys(context.raw).length + 1) ** 2;
+		while (head < queue.length && budget > 0) {
+			budget -= 1;
+			const name = queue[head];
+			head += 1;
+			if (name === void 0) break;
+			pending.delete(name);
+			context.converting.push(name);
+			const next = convert(context.raw[name], context);
+			context.converting.pop();
+			if (JSON.stringify(next) !== JSON.stringify(context.defs[name])) {
+				context.defs[name] = next;
+				const stale = [...context.dependents.get(name) ?? []].filter((reader) => !pending.has(reader));
+				for (const dependent of stale) {
+					pending.add(dependent);
+					queue.push(dependent);
+				}
+			}
+		}
+	}
+	return {
+		root: convert(schema, context),
+		defs: context.defs
+	};
+}
+function defType(name, context) {
+	const reader = context.converting.at(-1);
+	if (reader !== void 0 && reader !== name) {
+		const readers = context.dependents.get(name);
+		if (readers) readers.add(reader);
+		else context.dependents.set(name, /* @__PURE__ */ new Set([reader]));
+	}
+	if (Object.hasOwn(context.defs, name)) return context.defs[name] ?? null;
+	if (context.resolving.has(name)) {
+		for (const pending of context.converting) context.tainted.add(pending);
+		const cycleStart = context.converting.lastIndexOf(name);
+		if (cycleStart === -1) context.cyclic.add(name);
+		else for (const member of context.converting.slice(cycleStart)) context.cyclic.add(member);
+		return null;
+	}
+	if (!Object.hasOwn(context.raw, name)) return null;
+	context.resolving.add(name);
+	context.converting.push(name);
+	const type = convert(context.raw[name], context);
+	context.converting.pop();
+	context.resolving.delete(name);
+	context.defs[name] = type;
+	return type;
+}
+function convert(node, context) {
+	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)) {
+		const branches = node.allOf.map((entry) => convert(entry, context));
+		return requireFields(mergeAll(isObject(node.properties) ? [...branches, objectType(node, context)] : branches, context, "all"), node.required, context);
+	}
+	const union = node.anyOf ?? node.oneOf;
+	if (Array.isArray(union)) {
+		const viable = union.filter((branch) => unionBranchKind(branch, context) !== "impossible");
+		const nonNull = viable.filter((branch) => unionBranchKind(branch, context) !== "null");
+		if (viable.length === 0) return ANY;
+		if (nonNull.length === 0) return NULL;
+		const merged = nonNull.length === 1 ? convert(nonNull[0], context) : mergeAll(nonNull.map((entry) => convert(entry, context)), context, "any");
+		return requireFields(isObject(node.properties) ? mergeAll([merged, objectType(node, context)], context, "all") : merged, node.required, context);
+	}
+	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 (isObjectShape(node)) return objectType(node, context);
+	if (type === "array") return {
+		kind: "array",
+		element: convert(Array.isArray(node.items) ? node.items[0] : node.items, context)
+	};
+	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 isObjectShape(node) {
+	return primaryType(node) === "object" || isObject(node.properties);
+}
+function objectType(node, context) {
+	const properties = asObject(node.properties);
+	const required = new Set(Array.isArray(node.required) ? node.required.filter((name) => typeof name === "string") : []);
+	const fields = Object.create(null);
+	for (const [name, sub] of Object.entries(properties)) fields[name] = {
+		type: convert(sub, context),
+		required: required.has(name),
+		nullable: isNullable(sub, context),
+		doc: description(sub)
+	};
+	return {
+		kind: "object",
+		fields
+	};
+}
+function mergeAll(types, context, mode) {
+	const [only] = types;
+	if (only && types.length === 1) return only;
+	const fields = Object.create(null);
+	const appearances = /* @__PURE__ */ new Map();
+	let branches = 0;
+	for (const type of types) {
+		const resolved = derefFully(type, context);
+		if (resolved?.kind === "object") {
+			branches += 1;
+			for (const [name, field] of Object.entries(resolved.fields)) {
+				const existing = fields[name];
+				fields[name] = existing ? mergeField(existing, field, mode) : field;
+				appearances.set(name, (appearances.get(name) ?? 0) + 1);
+			}
+		}
+	}
+	if (branches > 0) {
+		if (mode === "any") {
+			for (const [name, field] of Object.entries(fields)) if (field.required && appearances.get(name) !== types.length) fields[name] = {
+				...field,
+				required: false
+			};
+		}
+		return {
+			kind: "object",
+			fields
+		};
+	}
+	return types.find((type) => type.kind !== "any") ?? ANY;
+}
+function requireFields(type, required, context) {
+	const names = Array.isArray(required) ? required.filter((name) => typeof name === "string") : [];
+	if (names.length === 0) return type;
+	const resolved = type.kind === "ref" ? derefNonCyclic(type, context) : type;
+	if (resolved === null || resolved.kind !== "object") return type;
+	const fields = Object.assign(Object.create(null), resolved.fields);
+	let changed = false;
+	for (const name of names) {
+		const field = fields[name];
+		if (field && !field.required) {
+			fields[name] = {
+				...field,
+				required: true
+			};
+			changed = true;
+		}
+	}
+	return changed ? {
+		kind: "object",
+		fields
+	} : type;
+}
+function mergeField(existing, incoming, mode) {
+	return {
+		type: incoming.type,
+		required: mode === "all" ? existing.required || incoming.required : existing.required && incoming.required,
+		nullable: mode === "all" ? existing.nullable && incoming.nullable : existing.nullable || incoming.nullable,
+		doc: incoming.doc ?? existing.doc
+	};
+}
+function derefFully(type, context) {
+	return followRefs(type, (name) => defType(name, context));
+}
+function derefNonCyclic(type, context) {
+	let current = type;
+	for (let i = 0; i < MAX_DEREF && current.kind === "ref"; i++) {
+		if (context.cyclic.has(current.name)) return null;
+		const next = defType(current.name, context);
+		if (!next) return null;
+		current = next;
+	}
+	return current.kind === "ref" ? null : current;
+}
+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 = Object.create(null);
+	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, context) {
+	const pending = [node];
+	const seenRefs = /* @__PURE__ */ new Set();
+	while (pending.length > 0) {
+		const current = pending.pop();
+		if (!isObject(current)) continue;
+		const { type } = current;
+		if (type === "null" || Array.isArray(type) && type.includes("null")) return true;
+		const ref = refName(current.$ref);
+		if (ref !== null && !seenRefs.has(ref) && Object.hasOwn(context.raw, ref)) {
+			seenRefs.add(ref);
+			pending.push(context.raw[ref]);
+			continue;
+		}
+		const union = current.anyOf ?? current.oneOf;
+		if (Array.isArray(union)) pending.push(...union);
+	}
+	return false;
+}
+function unionBranchKind(branch, context) {
+	const seenRefs = /* @__PURE__ */ new Set();
+	let current = branch;
+	for (let i = 0; i < MAX_DEREF; i++) {
+		if (current === false) return "impossible";
+		if (!isObject(current)) return "other";
+		if (current.type === "null" || Array.isArray(current.type) && current.type.length === 1 && current.type[0] === "null") return "null";
+		const ref = refName(current.$ref);
+		if (ref === null || seenRefs.has(ref) || !Object.hasOwn(context.raw, ref)) return "other";
+		seenRefs.add(ref);
+		current = context.raw[ref];
+	}
+	return "other";
+}
+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
+export { setMinijinjaContext as a, resolveMembers as i, minijinjaContextField as n, typeAtPath as o, normalizeContext as r, elementType as t };