@coldsmirk/inkstone-codemirror 0.8.2

package/README.md

@@ -0,0 +1,54 @@
+# @coldsmirk/inkstone-codemirror
+
+Framework-agnostic [CodeMirror 6](https://codemirror.net/) plumbing: a controlled editor host (create-once, external-value reconcile, in-place theme swap), the standard document extension bundle, lazy per-language grammar loading, and precise [MiniJinja](https://github.com/mitsuhiko/minijinja) template support with schema-driven context completion.
+
+Part of [inkstone](https://github.com/coldsmirk/inkstone). For a drop-in React component use [`@coldsmirk/inkstone-react`](https://www.npmjs.com/package/@coldsmirk/inkstone-react)'s `<CodeMirrorEditor>`, which is built on this package; reach for this layer to wire the same plumbing into your own components (any framework).
+
+## What you get
+
+- **`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.
+- **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.
+
+## Install
+
+```bash
+pnpm add @coldsmirk/inkstone-codemirror \
+  @codemirror/state @codemirror/view @codemirror/language @codemirror/autocomplete @codemirror/commands @codemirror/search
+```
+
+The `@codemirror/*` packages are **peer dependencies** on purpose: `@codemirror/state` breaks at runtime if two copies load, so your app owns the single copy and every extension is guaranteed to be built against it. Node.js >= 22 for build / SSR hosts.
+
+## Quick start
+
+```ts
+import { ControlledEditorHost, documentExtensions, loadLanguage } from "@coldsmirk/inkstone-codemirror";
+
+const host = new ControlledEditorHost({
+  parent: document.querySelector("#editor")!,
+  doc: "{\n}\n",
+  extensions: [documentExtensions({ showLineNumbers: true }), await loadLanguage("json")],
+  onChange: next => save(next)
+});
+
+// Later: external value changes reconcile without resetting cursor/undo.
+host.setValue(remoteValue);
+```
+
+For MiniJinja with context completion:
+
+```ts
+import { loadLanguage, normalizeContext, setMinijinjaContext } from "@coldsmirk/inkstone-codemirror";
+
+// include `await loadLanguage("minijinja")` in the host's extensions, then:
+view.dispatch({ effects: setMinijinjaContext.of(normalizeContext({ schema })) });
+```
+
+The completion is **structural** — it walks the declared shape (member access along a literal path), not types produced by filters or arithmetic. For a Rust backend the schema is nearly free: derive it from the same `serde` struct you render with via [`schemars`](https://docs.rs/schemars), and the completion can't drift from the real context.
+
+## License
+
+UNLICENSED — proprietary. All rights reserved; no use, copying, or redistribution without the author's permission.

package/dist/context-BDibyUwD.cjs

@@ -0,0 +1,270 @@
+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;
+	}
+});

package/dist/context-Dx6bPnKq.js

@@ -0,0 +1,235 @@
+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) {
+	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
+export { setMinijinjaContext as a, resolveMembers as i, minijinjaContextField as n, typeAtPath as o, normalizeContext as r, elementType as t };