@wallarm-org/design-system 1.30.0 → 1.31.0

package/dist/components/CodeEditor/engine/languages/jsonPointers.js

@@ -0,0 +1,125 @@
+import { ensureSyntaxTree, syntaxTree } from "@codemirror/language";
+const VALUE_NODE_NAMES = new Set([
+    'Object',
+    'Array',
+    'String',
+    'Number',
+    'True',
+    'False',
+    'Null'
+]);
+const ENSURE_TREE_TIMEOUT = 200;
+const escapePointerSegment = (segment)=>segment.replaceAll('~', '~0').replaceAll('/', '~1');
+const isValueNode = (node)=>VALUE_NODE_NAMES.has(node.name);
+const readJsonKey = (state, node)=>{
+    const raw = state.sliceDoc(node.from, node.to);
+    try {
+        const parsed = JSON.parse(raw);
+        if ('string' == typeof parsed) return parsed;
+    } catch  {}
+    return raw.slice(1, raw.endsWith('"') && raw.length > 1 ? -1 : void 0);
+};
+const findJsonText = (state, region)=>{
+    const tree = ensureSyntaxTree(state, region.to, ENSURE_TREE_TIMEOUT) ?? syntaxTree(state);
+    for(let node = tree.resolveInner(region.from, 1); node; node = node.parent)if ('JsonText' === node.name) return node;
+    return null;
+};
+const firstValueChild = (node)=>{
+    for(let child = node.firstChild; child; child = child.nextSibling)if (isValueNode(child)) return child;
+    return null;
+};
+const collect = (state, value, pointer, key, out)=>{
+    const entry = {
+        pointer,
+        valueFrom: value.from,
+        valueTo: value.to
+    };
+    if (key) {
+        entry.keyFrom = key.from;
+        entry.keyTo = key.to;
+    }
+    out.set(pointer, entry);
+    if ('Object' === value.name) {
+        for (const property of value.getChildren('Property')){
+            const name = property.getChild('PropertyName');
+            const member = firstValueChild(property);
+            if (!name || !member) continue;
+            const segment = escapePointerSegment(readJsonKey(state, name));
+            collect(state, member, `${pointer}/${segment}`, name, out);
+        }
+        return;
+    }
+    if ('Array' === value.name) {
+        let index = 0;
+        for(let child = value.firstChild; child; child = child.nextSibling)if (isValueNode(child)) {
+            collect(state, child, `${pointer}/${index}`, null, out);
+            index++;
+        }
+    }
+};
+const getJsonPointers = (state, region)=>{
+    const out = new Map();
+    const jsonText = findJsonText(state, region);
+    const root = jsonText ? firstValueChild(jsonText) : null;
+    if (root) collect(state, root, '', null, out);
+    return out;
+};
+const pointerAt = (state, pos, region)=>{
+    let best;
+    let bestSize = 1 / 0;
+    for (const entry of getJsonPointers(state, region).values()){
+        const ranges = [
+            [
+                entry.valueFrom,
+                entry.valueTo
+            ]
+        ];
+        if (void 0 !== entry.keyFrom && void 0 !== entry.keyTo) ranges.push([
+            entry.keyFrom,
+            entry.keyTo
+        ]);
+        for (const [from, to] of ranges)if (!(pos < from) && !(pos > to) && !(to - from >= bestSize)) {
+            best = entry.pointer;
+            bestSize = to - from;
+        }
+    }
+    return best;
+};
+const readPartialJson = (state, value)=>{
+    if ('Object' === value.name) {
+        const out = {};
+        for (const property of value.getChildren('Property')){
+            const name = property.getChild('PropertyName');
+            const member = firstValueChild(property);
+            if (!name || !member) continue;
+            const data = readPartialJson(state, member);
+            if (void 0 !== data) Object.defineProperty(out, readJsonKey(state, name), {
+                value: data,
+                enumerable: true,
+                writable: true,
+                configurable: true
+            });
+        }
+        return out;
+    }
+    if ('Array' === value.name) {
+        const items = [];
+        for(let child = value.firstChild; child; child = child.nextSibling)if (isValueNode(child)) items.push(readPartialJson(state, child));
+        return items;
+    }
+    try {
+        return JSON.parse(state.sliceDoc(value.from, value.to));
+    } catch  {
+        return;
+    }
+};
+const readRegionData = (state, region)=>{
+    try {
+        return JSON.parse(state.sliceDoc(region.from, region.to));
+    } catch  {
+        const jsonText = findJsonText(state, region);
+        const root = jsonText ? firstValueChild(jsonText) : null;
+        return root ? readPartialJson(state, root) : void 0;
+    }
+};
+export { ENSURE_TREE_TIMEOUT, VALUE_NODE_NAMES, escapePointerSegment, findJsonText, getJsonPointers, isValueNode, pointerAt, readJsonKey, readPartialJson, readRegionData };

package/dist/components/CodeEditor/engine/languages/yaml.d.ts

@@ -0,0 +1,4 @@
+import { LanguageSupport, type LRLanguage } from '@codemirror/language';
+/** lang-yaml's YAML language with its syntax folds switched off (folds come only from the `folds` prop). */
+export declare const yamlEditorLanguage: LRLanguage;
+export declare const yaml: () => LanguageSupport;

package/dist/components/CodeEditor/engine/languages/yaml.js

@@ -0,0 +1,11 @@
+import { yamlLanguage } from "@codemirror/lang-yaml";
+import { LanguageSupport, foldNodeProp } from "@codemirror/language";
+const yamlEditorLanguage = yamlLanguage.configure({
+    props: [
+        foldNodeProp.add({
+            'FlowMapping FlowSequence Item Pair BlockLiteral': ()=>null
+        })
+    ]
+});
+const yaml = ()=>new LanguageSupport(yamlEditorLanguage);
+export { yaml, yamlEditorLanguage };

package/dist/components/CodeEditor/engine/lines.d.ts

@@ -0,0 +1,22 @@
+import type { CSSProperties } from 'react';
+import { type EditorState, type Extension } from '@codemirror/state';
+import { type DecorationSet } from '@codemirror/view';
+import type { LineConfig } from '../../CodeSnippet/CodeSnippetContext';
+export interface LinesConfig {
+    lines: Record<number, LineConfig>;
+    startingLineNumber: number;
+}
+/**
+ * Serialize React `CSSProperties` into an inline style string, following
+ * react-dom's rules: camelCase → kebab-case, custom properties kept as-is,
+ * numbers get `px` unless the property is unitless (or the value is 0),
+ * `null` / `undefined` / booleans / empty strings are skipped.
+ */
+export declare const cssPropertiesToString: (style: CSSProperties | undefined) => string;
+/**
+ * `lines` prop → line decorations (background, text colour, text style, className, style)
+ * and range marks. Rebuilt on every document change, keyed by absolute line number.
+ * `Prec.high` makes these marks the innermost spans so they win over painter token colours.
+ */
+export declare const linesExtension: (config: LinesConfig) => Extension;
+export declare const getLineDecorations: (state: EditorState) => DecorationSet;

package/dist/components/CodeEditor/engine/lines.js

@@ -0,0 +1,131 @@
+import { Facet, Prec, StateField } from "@codemirror/state";
+import { Decoration, EditorView } from "@codemirror/view";
+import { cn } from "../../../utils/cn.js";
+import { LINE_COLOR_STYLES } from "../../CodeSnippet/lib/lineStyles.js";
+import { getLineTextStyles } from "../../CodeSnippet/lib/lineUtils.js";
+import { lineNumberToDocLine } from "./positions.js";
+const DEFAULT_CONFIG = {
+    lines: {},
+    startingLineNumber: 1
+};
+const UNITLESS_PROPERTIES = new Set([
+    'animationIterationCount',
+    'aspectRatio',
+    'borderImageOutset',
+    'borderImageSlice',
+    'borderImageWidth',
+    'boxFlex',
+    'boxFlexGroup',
+    'boxOrdinalGroup',
+    'columnCount',
+    'columns',
+    'flex',
+    'flexGrow',
+    'flexPositive',
+    'flexShrink',
+    'flexNegative',
+    'flexOrder',
+    'gridArea',
+    'gridRow',
+    'gridRowEnd',
+    'gridRowSpan',
+    'gridRowStart',
+    'gridColumn',
+    'gridColumnEnd',
+    'gridColumnSpan',
+    'gridColumnStart',
+    'fontWeight',
+    'lineClamp',
+    'lineHeight',
+    'opacity',
+    'order',
+    'orphans',
+    'scale',
+    'tabSize',
+    'widows',
+    'zIndex',
+    'zoom',
+    'fillOpacity',
+    'floodOpacity',
+    'stopOpacity',
+    'strokeDasharray',
+    'strokeDashoffset',
+    'strokeMiterlimit',
+    'strokeOpacity',
+    'strokeWidth'
+]);
+const VENDOR_PREFIX = /^(Webkit|Moz|ms|O)(?=[A-Z])/;
+const isUnitless = (property)=>{
+    const unprefixed = property.replace(VENDOR_PREFIX, '');
+    const normalized = unprefixed === property ? property : unprefixed.charAt(0).toLowerCase() + unprefixed.slice(1);
+    return UNITLESS_PROPERTIES.has(normalized);
+};
+const toKebabCase = (property)=>{
+    if (property.startsWith('--')) return property;
+    const kebab = property.replace(/[A-Z]/g, (char)=>`-${char.toLowerCase()}`);
+    return kebab.startsWith('ms-') ? `-${kebab}` : kebab;
+};
+const cssPropertiesToString = (style)=>{
+    if (!style) return '';
+    const declarations = [];
+    for (const [property, rawValue] of Object.entries(style)){
+        const value = rawValue;
+        if (null == value || 'boolean' == typeof value || '' === value) continue;
+        const isCustom = property.startsWith('--');
+        let serialized;
+        serialized = 'number' == typeof value ? 0 === value || isCustom || isUnitless(property) ? String(value) : `${value}px` : String(value).trim();
+        declarations.push(`${toKebabCase(property)}: ${serialized}`);
+    }
+    return declarations.join('; ');
+};
+const linesConfigFacet = Facet.define({
+    combine: (values)=>values[values.length - 1] ?? DEFAULT_CONFIG
+});
+const buildLineDecorations = (state)=>{
+    const { lines, startingLineNumber } = state.facet(linesConfigFacet);
+    const decorations = [];
+    for (const [key, config] of Object.entries(lines)){
+        const line = lineNumberToDocLine(state.doc, Number(key), startingLineNumber);
+        if (!line) continue;
+        const { colorClass, textStyleClass, className, style } = getLineTextStyles(config);
+        const lineClass = cn(config.color ? LINE_COLOR_STYLES[config.color].bg : void 0, colorClass, textStyleClass, className);
+        const styleString = cssPropertiesToString(style);
+        if (lineClass || styleString) decorations.push(Decoration.line({
+            ...lineClass ? {
+                class: lineClass
+            } : {},
+            ...styleString ? {
+                attributes: {
+                    style: styleString
+                }
+            } : {}
+        }).range(line.from));
+        if (colorClass && line.length > 0) decorations.push(Decoration.mark({
+            class: colorClass
+        }).range(line.from, line.to));
+        for (const range of config.ranges ?? []){
+            const resolvedColor = range.color ?? config.color;
+            if (!resolvedColor) continue;
+            const start = Math.max(range.start, 0);
+            const end = Math.min(range.end, line.length);
+            if (!(start >= end)) decorations.push(Decoration.mark({
+                class: LINE_COLOR_STYLES[resolvedColor].text
+            }).range(line.from + start, line.from + end));
+        }
+    }
+    return Decoration.set(decorations, true);
+};
+const linesField = StateField.define({
+    create: buildLineDecorations,
+    update: (value, tr)=>{
+        if (tr.docChanged || tr.startState.facet(linesConfigFacet) !== tr.state.facet(linesConfigFacet)) return buildLineDecorations(tr.state);
+        return value;
+    },
+    provide: (field)=>EditorView.decorations.from(field)
+});
+const linesExtension = (config)=>[
+        linesConfigFacet.of(config),
+        Prec.high(linesField)
+    ];
+const getLineDecorations = (state)=>state.field(linesField, false) ?? Decoration.none;
+export { cssPropertiesToString, getLineDecorations, linesExtension };

package/dist/components/CodeEditor/engine/luaSyntax.d.ts

@@ -0,0 +1,14 @@
+import type { Diagnostic } from '@codemirror/lint';
+type LuaParser = typeof import('luaparse');
+/** Cached `import('luaparse')` — loaded only for lua documents. A failed load is retried next time. */
+export declare const loadLuaParser: () => Promise<LuaParser>;
+/**
+ * Syntax diagnostics for `text` from an already loaded luaparse: at most one (luaparse stops at the
+ * first error), at `error.index` covering one character (clamped to the text end). `base` shifts
+ * offsets into the document. `luaVersion: '5.3'` is the most permissive grammar (goto, `//`,
+ * bitwise operators), which also covers OpenResty/LuaJIT code.
+ */
+export declare const luaDiagnostics: (parser: LuaParser, text: string, base?: number) => Diagnostic[];
+/** Loads luaparse (cached) and returns the syntax diagnostics of `text`. */
+export declare const luaSyntaxDiagnostics: (text: string) => Promise<Diagnostic[]>;
+export {};

package/dist/components/CodeEditor/engine/luaSyntax.js

@@ -0,0 +1,36 @@
+let pending = null;
+const loadLuaParser = ()=>{
+    if (!pending) pending = import("luaparse").catch((error)=>{
+        pending = null;
+        throw error;
+    });
+    return pending;
+};
+const isLuaParseError = (value)=>'object' == typeof value && null !== value && 'number' == typeof value.index && 'string' == typeof value.message;
+const stripLocation = (message)=>message.replace(/^\[\d+:\d+\]\s*/, '');
+const luaDiagnostics = (parser, text, base = 0)=>{
+    try {
+        parser.parse(text, {
+            luaVersion: '5.3',
+            comments: false,
+            locations: false,
+            ranges: false,
+            scope: false
+        });
+        return [];
+    } catch (error) {
+        if (!isLuaParseError(error)) return [];
+        const from = Math.min(Math.max(error.index, 0), text.length);
+        return [
+            {
+                from: base + from,
+                to: base + Math.min(from + 1, text.length),
+                severity: 'error',
+                source: 'syntax',
+                message: stripLocation(error.message)
+            }
+        ];
+    }
+};
+const luaSyntaxDiagnostics = async (text)=>luaDiagnostics(await loadLuaParser(), text);
+export { loadLuaParser, luaDiagnostics, luaSyntaxDiagnostics };

package/dist/components/CodeEditor/engine/positions.d.ts

@@ -0,0 +1,19 @@
+import type { Line, Text } from '@codemirror/state';
+import type { CodeEditorPosition } from '../types';
+/**
+ * Converts a document offset into an absolute (startingLineNumber-based) line and 1-based column.
+ * Offsets outside the document are clamped to its bounds.
+ */
+export declare const offsetToPosition: (doc: Text, offset: number, startingLineNumber: number) => CodeEditorPosition;
+/**
+ * Returns the document line for an absolute (startingLineNumber-based) line number,
+ * or `null` when it is outside the document.
+ */
+export declare const lineNumberToDocLine: (doc: Text, absoluteLine: number, startingLineNumber: number) => Line | null;
+/**
+ * Converts an absolute line + 1-based column into a document offset.
+ * Returns `null` when the line is outside the document; the column is clamped to
+ * `[1, line.length + 1]` (column `line.length + 1` is the end of the line). A non-finite
+ * column (`NaN`, `±Infinity`) is treated as column 1 so a bad value can never yield `NaN`.
+ */
+export declare const positionToOffset: (doc: Text, position: CodeEditorPosition, startingLineNumber: number) => number | null;

package/dist/components/CodeEditor/engine/positions.js

@@ -0,0 +1,22 @@
+const clamp = (value, min, max)=>Math.min(Math.max(value, min), max);
+const offsetToPosition = (doc, offset, startingLineNumber)=>{
+    const safeOffset = clamp(offset, 0, doc.length);
+    const line = doc.lineAt(safeOffset);
+    return {
+        line: line.number + startingLineNumber - 1,
+        column: safeOffset - line.from + 1
+    };
+};
+const lineNumberToDocLine = (doc, absoluteLine, startingLineNumber)=>{
+    const docLineNumber = absoluteLine - startingLineNumber + 1;
+    if (!Number.isInteger(docLineNumber) || docLineNumber < 1 || docLineNumber > doc.lines) return null;
+    return doc.line(docLineNumber);
+};
+const positionToOffset = (doc, position, startingLineNumber)=>{
+    const line = lineNumberToDocLine(doc, position.line, startingLineNumber);
+    if (!line) return null;
+    const raw = Number.isFinite(position.column) ? Math.floor(position.column) : 1;
+    const column = clamp(raw, 1, line.length + 1);
+    return line.from + column - 1;
+};
+export { lineNumberToDocLine, offsetToPosition, positionToOffset };

package/dist/components/CodeEditor/engine/schema/complete.d.ts

@@ -0,0 +1,12 @@
+import { type CompletionSource } from '@codemirror/autocomplete';
+import type { EditorState } from '@codemirror/state';
+import type { JsonSchema } from '../../types';
+/**
+ * JSON Schema completions for the JSON region (spec §7.13): missing property names in key
+ * position, `enum` / `const` / boolean values in value position. Registered by Task 14.
+ * Never rejects: a broken schema or a failed chunk load yields `null`.
+ */
+export declare const schemaCompletionSource: (getSchema: () => JsonSchema | undefined, getRegion: (state: EditorState) => {
+    from: number;
+    to: number;
+} | null) => CompletionSource;

package/dist/components/CodeEditor/engine/schema/complete.js

@@ -0,0 +1,211 @@
+import { insertCompletionText, pickedCompletion } from "@codemirror/autocomplete";
+import { ensureSyntaxTree, syntaxTree } from "@codemirror/language";
+import { ENSURE_TREE_TIMEOUT, escapePointerSegment, getJsonPointers, isValueNode, readJsonKey, readPartialJson, readRegionData } from "../languages/jsonPointers.js";
+import { getCompiledSchema } from "./loadSchema.js";
+const WORD_BEFORE = /[\w$.+-]*$/;
+const WORD_AFTER = /^[\w$.+-]*/;
+const WHITESPACE = /\s/;
+const tokenAt = (state, pos, region)=>{
+    const line = state.doc.lineAt(pos);
+    const start = Math.max(line.from, region.from);
+    const end = Math.min(line.to, region.to);
+    const before = state.sliceDoc(start, pos);
+    const after = state.sliceDoc(pos, end);
+    let stringStart = -1;
+    for(let i = 0; i < before.length; i++){
+        const ch = before[i];
+        if (stringStart < 0) {
+            if ('"' === ch) stringStart = i;
+        } else if ('\\' === ch) i++;
+        else if ('"' === ch) stringStart = -1;
+    }
+    if (stringStart >= 0) {
+        for(let i = 0; i < after.length; i++)if ('\\' === after[i]) i++;
+        else if ('"' === after[i]) return {
+            from: start + stringStart,
+            to: pos + i + 1,
+            kind: 'string',
+            closed: true
+        };
+        return {
+            from: start + stringStart,
+            to: pos,
+            kind: 'string',
+            closed: false
+        };
+    }
+    const wordBefore = WORD_BEFORE.exec(before)?.[0] ?? '';
+    const wordAfter = WORD_AFTER.exec(after)?.[0] ?? '';
+    return {
+        from: pos - wordBefore.length,
+        to: pos + wordAfter.length,
+        kind: 'word',
+        closed: false
+    };
+};
+const significantChar = (state, pos, region, direction)=>{
+    for(let p = direction < 0 ? pos - 1 : pos; p >= region.from && p < region.to; p += direction){
+        const ch = state.sliceDoc(p, p + 1);
+        if (!WHITESPACE.test(ch)) return {
+            ch,
+            pos: p
+        };
+    }
+    return null;
+};
+const ancestor = (node, names)=>{
+    for(let current = node; current; current = current.parent){
+        if (names.includes(current.name)) return current;
+        if ('JsonText' === current.name) break;
+    }
+    return null;
+};
+const targetAt = (state, token, region)=>{
+    const previous = significantChar(state, token.from, region, -1);
+    if (!previous) return null;
+    const tree = ensureSyntaxTree(state, token.to, ENSURE_TREE_TIMEOUT) ?? syntaxTree(state);
+    const punctuation = tree.resolveInner(previous.pos + 1, -1);
+    if (':' === previous.ch) {
+        const property = ancestor(punctuation, [
+            'Property'
+        ]);
+        const name = property?.getChild('PropertyName');
+        const container = property?.parent;
+        if (!name || !container || 'Object' !== container.name) return null;
+        return {
+            role: 'value',
+            container,
+            key: readJsonKey(state, name)
+        };
+    }
+    if ('{' !== previous.ch && '[' !== previous.ch && ',' !== previous.ch) return null;
+    const container = ancestor(punctuation, [
+        'Object',
+        'Array'
+    ]);
+    if (!container) return null;
+    if ('Object' === container.name) return '[' === previous.ch ? null : {
+        role: 'key',
+        container
+    };
+    if ('{' === previous.ch) return null;
+    let index = 0;
+    for(let child = container.firstChild; child; child = child.nextSibling)if (isValueNode(child) && child.to <= token.from) index++;
+    return {
+        role: 'value',
+        container,
+        key: index
+    };
+};
+const applyText = (text, tail)=>0 === tail ? text : (view, completion, from, to)=>{
+        view.dispatch({
+            ...insertCompletionText(view.state, text, from, to + tail),
+            annotations: pickedCompletion.of(completion)
+        });
+    };
+const typeLabel = (schema)=>{
+    const type = schema.type;
+    if ('string' == typeof type) return type;
+    if (Array.isArray(type)) return type.filter((item)=>'string' == typeof item).join(' | ');
+    if (Array.isArray(schema.enum)) return 'enum';
+    if ('const' in schema) return 'const';
+    return '';
+};
+const hasType = (schema, name)=>{
+    const type = schema.type;
+    return type === name || Array.isArray(type) && type.includes(name);
+};
+const stringOrUndefined = (value)=>'string' == typeof value && '' !== value ? value : void 0;
+const presentKeys = (state, object, editing)=>{
+    const keys = new Set();
+    for (const property of object.getChildren('Property')){
+        const name = property.getChild('PropertyName');
+        if (name && name.from !== editing.from) keys.add(readJsonKey(state, name));
+    }
+    return keys;
+};
+const propertyOptions = (node, present, render)=>{
+    const required = new Set(node.required ?? []);
+    const options = [];
+    for (const [name, child] of Object.entries(node.properties ?? {})){
+        if (present.has(name)) continue;
+        const schema = (node.getNodeChild(name).node ?? child).schema;
+        const type = typeLabel(schema);
+        const isRequired = required.has(name);
+        options.push({
+            label: name,
+            apply: render(name),
+            type: 'property',
+            detail: isRequired ? type ? `${type} (required)` : 'required' : type || void 0,
+            info: stringOrUndefined(schema.description),
+            boost: isRequired ? 1 : 0
+        });
+    }
+    return options;
+};
+const valueOptions = (node, tail)=>{
+    const { schema } = node;
+    const values = [];
+    if (Array.isArray(schema.enum)) values.push(...schema.enum);
+    if ('const' in schema) values.push(schema.const);
+    if (hasType(schema, 'boolean')) values.push(true, false);
+    const seen = new Set();
+    const options = [];
+    for (const value of values){
+        const text = JSON.stringify(value);
+        if (!(void 0 === text || seen.has(text))) {
+            seen.add(text);
+            options.push({
+                label: text,
+                apply: applyText(text, tail),
+                type: 'value',
+                info: stringOrUndefined(schema.description)
+            });
+        }
+    }
+    return options;
+};
+const completeAt = async (context, getRegion, schema)=>{
+    const { state, pos } = context;
+    const region = getRegion(state);
+    if (!region || pos < region.from || pos > region.to) return null;
+    const token = tokenAt(state, pos, region);
+    if ('word' === token.kind && token.from === pos && token.to === pos && !context.explicit) return null;
+    const target = targetAt(state, token, region);
+    if (!target) return null;
+    const containerEntry = [
+        ...getJsonPointers(state, region).values()
+    ].find((entry)=>entry.valueFrom === target.container.from);
+    if (!containerEntry) return null;
+    const pointer = 'key' === target.role ? containerEntry.pointer : `${containerEntry.pointer}/${escapePointerSegment(String(target.key))}`;
+    const root = await getCompiledSchema(schema);
+    const { node } = root.getNode(pointer, readRegionData(state, region));
+    if (!node) return null;
+    const tail = 'string' !== token.kind || token.closed ? token.to - pos : 0;
+    if ('value' === target.role) {
+        const options = valueOptions(node, tail);
+        return options.length > 0 ? {
+            from: token.from,
+            options
+        } : null;
+    }
+    const reduced = node.reduceNode(readPartialJson(state, target.container)).node ?? node;
+    const next = significantChar(state, token.to, region, 1);
+    const suffix = next?.ch === ':' ? '' : ': ';
+    const inString = 'string' === token.kind;
+    const options = propertyOptions(reduced, presentKeys(state, target.container, token), (name)=>{
+        const quoted = JSON.stringify(name);
+        return applyText(inString ? `${quoted.slice(1)}${suffix}` : `${quoted}${suffix}`, tail);
+    });
+    if (0 === options.length) return null;
+    return {
+        from: inString ? token.from + 1 : token.from,
+        options
+    };
+};
+const schemaCompletionSource = (getSchema, getRegion)=>(context)=>{
+        const schema = getSchema();
+        if (void 0 === schema) return Promise.resolve(null);
+        return completeAt(context, getRegion, schema).catch(()=>null);
+    };
+export { schemaCompletionSource };

package/dist/components/CodeEditor/engine/schema/hover.d.ts

@@ -0,0 +1,12 @@
+import type { EditorState, Extension } from '@codemirror/state';
+import { type HoverTooltipSource } from '@codemirror/view';
+import type { JsonSchema } from '../../types';
+/** Hover source: `title` / `description` of the schema for the property under the pointer. */
+export declare const schemaHoverSource: (getSchema: () => JsonSchema | undefined, getRegion: (state: EditorState) => {
+    from: number;
+    to: number;
+} | null) => HoverTooltipSource;
+export declare const schemaHover: (getSchema: () => JsonSchema | undefined, getRegion: (state: EditorState) => {
+    from: number;
+    to: number;
+} | null) => Extension;