@wallarm-org/design-system 1.30.0 → 1.31.0

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

@@ -0,0 +1,201 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useCallback } from "react";
+import { SearchQuery, closeSearchPanel, findNext, findPrevious, replaceAll, replaceNext, setSearchQuery } from "@codemirror/search";
+import { EditorView, runScopeHandlers } from "@codemirror/view";
+import { ChevronDown } from "../../../icons/ChevronDown.js";
+import { ChevronUp } from "../../../icons/ChevronUp.js";
+import { X } from "../../../icons/X.js";
+import { cn } from "../../../utils/cn.js";
+import { Button } from "../../Button/index.js";
+import { Input } from "../../Input/index.js";
+import { ToggleButton } from "../../ToggleButton/index.js";
+import { countMatches, matchCountMessage } from "./searchMatches.js";
+const rowClassName = 'flex h-32 items-center gap-4 px-6';
+const SearchPanel = ({ view, query, matchCount, readOnly, testId })=>{
+    const slot = (name)=>testId ? `${testId}--${name}` : void 0;
+    const focusOnMount = useCallback((input)=>{
+        input?.focus();
+        input?.select();
+    }, []);
+    const updateQuery = (patch)=>{
+        const next = new SearchQuery({
+            search: query.search,
+            replace: query.replace,
+            caseSensitive: query.caseSensitive,
+            regexp: query.regexp,
+            wholeWord: query.wholeWord,
+            literal: query.literal,
+            ...patch
+        });
+        if (next.eq(query)) return;
+        const effects = [
+            setSearchQuery.of(next)
+        ];
+        const announce = '' === next.search ? [] : [
+            EditorView.announce.of(next.valid ? matchCountMessage(countMatches(view.state, next)) : 'Invalid regular expression')
+        ];
+        view.dispatch({
+            effects: [
+                ...effects,
+                ...announce
+            ]
+        });
+    };
+    const handleKeyDown = (event, onEnter)=>{
+        if (event.nativeEvent.isComposing || 229 === event.keyCode) return;
+        if (runScopeHandlers(view, event.nativeEvent, 'search-panel')) return void event.preventDefault();
+        if ('Enter' === event.key) {
+            event.preventDefault();
+            onEnter(event.shiftKey);
+        }
+    };
+    const handleFindKeyDown = (event)=>handleKeyDown(event, (shift)=>(shift ? findPrevious : findNext)(view));
+    const handleReplaceKeyDown = (event)=>handleKeyDown(event, ()=>replaceNext(view));
+    const handlePanelKeyDown = (event)=>{
+        if (event.target instanceof HTMLInputElement) return;
+        if (runScopeHandlers(view, event.nativeEvent, 'search-panel')) event.preventDefault();
+    };
+    const canSearch = query.valid;
+    return /*#__PURE__*/ jsxs("div", {
+        role: "search",
+        "aria-label": "Find and replace",
+        "data-slot": "code-editor-search",
+        "data-testid": slot('search'),
+        className: "flex flex-col border-b border-border-primary-light code-snippet-bg font-sans",
+        onKeyDown: handlePanelKeyDown,
+        children: [
+            /*#__PURE__*/ jsxs("div", {
+                className: rowClassName,
+                children: [
+                    /*#__PURE__*/ jsx(Input, {
+                        ref: focusOnMount,
+                        size: "small",
+                        className: "w-240",
+                        placeholder: "Find",
+                        "aria-label": "Find",
+                        "main-field": "true",
+                        value: query.search,
+                        error: '' !== query.search && !canSearch,
+                        "data-testid": slot('search-input'),
+                        onChange: (event)=>updateQuery({
+                                search: event.target.value
+                            }),
+                        onKeyDown: handleFindKeyDown
+                    }),
+                    /*#__PURE__*/ jsx("span", {
+                        "aria-hidden": "true",
+                        className: cn('min-w-72 text-xs text-text-secondary whitespace-nowrap', !canSearch && 'invisible'),
+                        "data-testid": slot('search-count'),
+                        children: null === matchCount ? '' : matchCountMessage(matchCount)
+                    }),
+                    /*#__PURE__*/ jsx(ToggleButton, {
+                        variant: "ghost",
+                        color: "neutral",
+                        size: "small",
+                        active: query.caseSensitive,
+                        "aria-pressed": query.caseSensitive,
+                        "aria-label": "Match case",
+                        "data-testid": slot('search-case'),
+                        onToggle: (active)=>updateQuery({
+                                caseSensitive: active
+                            }),
+                        children: "Aa"
+                    }),
+                    /*#__PURE__*/ jsx(ToggleButton, {
+                        variant: "ghost",
+                        color: "neutral",
+                        size: "small",
+                        active: query.wholeWord,
+                        "aria-pressed": query.wholeWord,
+                        "aria-label": "Match whole word",
+                        "data-testid": slot('search-whole-word'),
+                        onToggle: (active)=>updateQuery({
+                                wholeWord: active
+                            }),
+                        children: "W"
+                    }),
+                    /*#__PURE__*/ jsx(ToggleButton, {
+                        variant: "ghost",
+                        color: "neutral",
+                        size: "small",
+                        active: query.regexp,
+                        "aria-pressed": query.regexp,
+                        "aria-label": "Use regular expression",
+                        "data-testid": slot('search-regexp'),
+                        onToggle: (active)=>updateQuery({
+                                regexp: active
+                            }),
+                        children: ".*"
+                    }),
+                    /*#__PURE__*/ jsx(Button, {
+                        variant: "ghost",
+                        color: "neutral",
+                        size: "small",
+                        "aria-label": "Previous match",
+                        disabled: !canSearch,
+                        "data-testid": slot('search-previous'),
+                        onClick: ()=>findPrevious(view),
+                        children: /*#__PURE__*/ jsx(ChevronUp, {})
+                    }),
+                    /*#__PURE__*/ jsx(Button, {
+                        variant: "ghost",
+                        color: "neutral",
+                        size: "small",
+                        "aria-label": "Next match",
+                        disabled: !canSearch,
+                        "data-testid": slot('search-next'),
+                        onClick: ()=>findNext(view),
+                        children: /*#__PURE__*/ jsx(ChevronDown, {})
+                    }),
+                    /*#__PURE__*/ jsx(Button, {
+                        variant: "ghost",
+                        color: "neutral",
+                        size: "small",
+                        className: "ml-auto",
+                        "aria-label": "Close search",
+                        "data-testid": slot('search-close'),
+                        onClick: ()=>closeSearchPanel(view),
+                        children: /*#__PURE__*/ jsx(X, {})
+                    })
+                ]
+            }),
+            !readOnly && /*#__PURE__*/ jsxs("div", {
+                className: rowClassName,
+                children: [
+                    /*#__PURE__*/ jsx(Input, {
+                        size: "small",
+                        className: "w-240",
+                        placeholder: "Replace",
+                        "aria-label": "Replace",
+                        value: query.replace,
+                        "data-testid": slot('replace-input'),
+                        onChange: (event)=>updateQuery({
+                                replace: event.target.value
+                            }),
+                        onKeyDown: handleReplaceKeyDown
+                    }),
+                    /*#__PURE__*/ jsx(Button, {
+                        variant: "ghost",
+                        color: "neutral",
+                        size: "small",
+                        disabled: !canSearch,
+                        "data-testid": slot('replace-next'),
+                        onClick: ()=>replaceNext(view),
+                        children: "Replace"
+                    }),
+                    /*#__PURE__*/ jsx(Button, {
+                        variant: "ghost",
+                        color: "neutral",
+                        size: "small",
+                        disabled: !canSearch,
+                        "data-testid": slot('replace-all'),
+                        onClick: ()=>replaceAll(view),
+                        children: "Replace all"
+                    })
+                ]
+            })
+        ]
+    });
+};
+SearchPanel.displayName = 'SearchPanel';
+export { SearchPanel };

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

@@ -0,0 +1,23 @@
+import { type Extension, type Text } from '@codemirror/state';
+import { type DecorationSet, type EditorView } from '@codemirror/view';
+import type { HighlightResult, SyntaxAdapter } from '../../CodeSnippet/adapters/types';
+/** Delay between the last document change and the adapter re-highlight (spec §7.3). */
+export declare const DEFAULT_PAINT_DEBOUNCE_MS = 100;
+/**
+ * Converts an adapter result (tokens per line, offsets implied by `content.length`)
+ * into mark decorations over `doc`. Lines or token text beyond the document are clamped,
+ * so a result that does not exactly match the document never throws.
+ */
+export declare const buildTokenDecorations: (doc: Text, result: HighlightResult) => DecorationSet;
+/**
+ * Paints `SyntaxAdapter` tokens as mark decorations (spec §7.3, D3).
+ * Every call returns a new plugin spec, so reconfiguring the painter compartment with a
+ * new adapter/language destroys the old instance and highlights again from scratch.
+ */
+export declare const adapterPainter: (config: {
+    adapter: SyntaxAdapter<string>;
+    language: string;
+    debounceMs?: number;
+}) => Extension;
+/** The painter's current token decorations (tests / diagnostics only). */
+export declare const getPaintedDecorations: (view: EditorView) => DecorationSet;

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

@@ -0,0 +1,110 @@
+import { RangeSetBuilder, StateEffect } from "@codemirror/state";
+import { Decoration, ViewPlugin } from "@codemirror/view";
+import { TOKEN_CLASSES } from "../../CodeSnippet/internal/CodeToken.js";
+const DEFAULT_PAINT_DEBOUNCE_MS = 100;
+const paintEffect = StateEffect.define();
+const markCache = new Map();
+const markFor = (className)=>{
+    let mark = markCache.get(className);
+    if (!mark) {
+        mark = Decoration.mark({
+            class: className
+        });
+        markCache.set(className, mark);
+    }
+    return mark;
+};
+const tokenClass = (className, type)=>{
+    if (void 0 !== className) return '' === className ? null : className;
+    if ('plain' === type) return null;
+    return TOKEN_CLASSES[type];
+};
+const buildTokenDecorations = (doc, result)=>{
+    const builder = new RangeSetBuilder();
+    const lineCount = Math.min(result.tokens.length, doc.lines);
+    for(let index = 0; index < lineCount; index++){
+        const line = doc.line(index + 1);
+        const lineTokens = result.tokens[index] ?? [];
+        let offset = line.from;
+        for (const token of lineTokens){
+            const from = offset;
+            offset += token.content.length;
+            if (from >= line.to) break;
+            const to = Math.min(offset, line.to);
+            if (to <= from) continue;
+            const className = tokenClass(token.className, token.type);
+            if (className) builder.add(from, to, markFor(className));
+        }
+    }
+    return builder.finish();
+};
+class PainterPluginValue {
+    decorations = Decoration.none;
+    view;
+    config;
+    docVersion = 0;
+    timer = null;
+    destroyed = false;
+    errorReported = false;
+    constructor(view, config){
+        this.view = view;
+        this.config = config;
+        this.request();
+    }
+    update(update) {
+        if (update.docChanged) {
+            this.decorations = this.decorations.map(update.changes);
+            this.docVersion++;
+            this.schedule();
+        }
+        for (const transaction of update.transactions)for (const effect of transaction.effects)if (effect.is(paintEffect)) this.decorations = effect.value;
+    }
+    destroy() {
+        this.destroyed = true;
+        if (null !== this.timer) clearTimeout(this.timer);
+        this.timer = null;
+    }
+    schedule() {
+        if (null !== this.timer) clearTimeout(this.timer);
+        this.timer = setTimeout(()=>{
+            this.timer = null;
+            this.request();
+        }, this.config.debounceMs);
+    }
+    request() {
+        const version = this.docVersion;
+        const doc = this.view.state.doc;
+        const { adapter, language } = this.config;
+        let pending;
+        try {
+            pending = adapter.highlight(doc.toString(), language);
+        } catch (error) {
+            this.reportError(error);
+            return;
+        }
+        pending.then((result)=>{
+            if (this.destroyed || version !== this.docVersion) return;
+            this.view.dispatch({
+                effects: paintEffect.of(buildTokenDecorations(doc, result))
+            });
+        }, (error)=>{
+            if (this.destroyed) return;
+            this.reportError(error);
+        });
+    }
+    reportError(error) {
+        if (this.errorReported) return;
+        this.errorReported = true;
+        console.error(`[CodeEditor] Syntax adapter "${this.config.adapter.name}" failed to highlight "${this.config.language}"; keeping previous colours.`, error);
+    }
+}
+const painterPlugin = ViewPlugin.fromClass(PainterPluginValue, {
+    decorations: (plugin)=>plugin.decorations
+});
+const adapterPainter = (config)=>painterPlugin.of({
+        adapter: config.adapter,
+        language: config.language,
+        debounceMs: config.debounceMs ?? DEFAULT_PAINT_DEBOUNCE_MS
+    });
+const getPaintedDecorations = (view)=>view.plugin(painterPlugin)?.decorations ?? Decoration.none;
+export { DEFAULT_PAINT_DEBOUNCE_MS, adapterPainter, buildTokenDecorations, getPaintedDecorations };

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

@@ -0,0 +1,15 @@
+import type { Diagnostic } from '@codemirror/lint';
+/** Languages whose syntax errors come from `@babel/parser` (spec §14 A5). */
+export type BabelLanguage = 'javascript' | 'typescript';
+type BabelParser = typeof import('@babel/parser');
+/** Cached `import('@babel/parser')` — loaded only for javascript/typescript documents. A failed load is retried next time. */
+export declare const loadBabelParser: () => Promise<BabelParser>;
+/**
+ * Syntax diagnostics for `text` from an already loaded Babel parser: recovered `errors[]` plus
+ * a thrown fatal error, each at `error.pos` covering one character (clamped to the text end),
+ * sorted, one per position. `base` shifts offsets into the document.
+ */
+export declare const babelDiagnostics: (parser: BabelParser, text: string, language: BabelLanguage, base?: number) => Diagnostic[];
+/** Loads Babel (cached) and returns the syntax diagnostics of `text`. */
+export declare const babelSyntaxDiagnostics: (text: string, language: BabelLanguage) => Promise<Diagnostic[]>;
+export {};

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

@@ -0,0 +1,54 @@
+let pending = null;
+const loadBabelParser = ()=>{
+    if (!pending) pending = import("@babel/parser").catch((error)=>{
+        pending = null;
+        throw error;
+    });
+    return pending;
+};
+const optionsFor = (language)=>({
+        sourceType: 'module',
+        errorRecovery: true,
+        allowReturnOutsideFunction: true,
+        plugins: "typescript" === language ? [
+            "typescript",
+            'explicitResourceManagement',
+            'decorators-legacy',
+            'decoratorAutoAccessors'
+        ] : [
+            'jsx',
+            'explicitResourceManagement',
+            'decorators',
+            'decoratorAutoAccessors'
+        ]
+    });
+const isPositionedError = (value)=>'object' == typeof value && null !== value && 'number' == typeof value.pos && 'string' == typeof value.message;
+const stripLocation = (message)=>message.replace(/ \(\d+:\d+\)$/, '');
+const babelDiagnostics = (parser, text, language, base = 0)=>{
+    const errors = [];
+    try {
+        const result = parser.parse(text, optionsFor(language));
+        errors.push(...result.errors ?? []);
+    } catch (error) {
+        errors.push(error);
+    }
+    const seen = new Set();
+    const out = [];
+    for (const error of errors){
+        if (!isPositionedError(error)) continue;
+        const from = Math.min(Math.max(error.pos, 0), text.length);
+        if (!seen.has(from)) {
+            seen.add(from);
+            out.push({
+                from: base + from,
+                to: base + Math.min(from + 1, text.length),
+                severity: 'error',
+                source: 'syntax',
+                message: stripLocation(error.message)
+            });
+        }
+    }
+    return out.sort((a, b)=>a.from - b.from);
+};
+const babelSyntaxDiagnostics = async (text, language)=>babelDiagnostics(await loadBabelParser(), text, language);
+export { babelDiagnostics, babelSyntaxDiagnostics, loadBabelParser };

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

@@ -0,0 +1,17 @@
+import { type CompletionContext } from '@codemirror/autocomplete';
+import type { Extension } from '@codemirror/state';
+import type { CodeEditorCompletionContext, CodeEditorCompletionSource, CodeEditorLanguage, JsonSchema } from '../types';
+/** Public, engine-free view of a CodeMirror completion request (spec §4). */
+export declare const buildCompletionContext: (ctx: CompletionContext, language: CodeEditorLanguage, startingLineNumber: number) => CodeEditorCompletionContext;
+/**
+ * Autocomplete (spec §7.14): built-in HTTP source for `http`, the JSON Schema source when
+ * `schema` is set, then consumer sources, all through `override` (language-data sources are
+ * off). `completionKeymap` comes with `defaultKeymap: true` at `Prec.highest`, so Enter,
+ * arrows and Escape reach the open list before `indentWithTab` / fullscreen Escape.
+ */
+export declare const completionExtension: (config: {
+    language: CodeEditorLanguage;
+    schema: JsonSchema | undefined;
+    sources: readonly CodeEditorCompletionSource[];
+    startingLineNumber: number;
+}) => Extension;

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

@@ -0,0 +1,129 @@
+import { autocompletion } from "@codemirror/autocomplete";
+import { EditorView } from "@codemirror/view";
+import { cn } from "../../../utils/cn.js";
+import { dropdownMenuItemVariants } from "../../DropdownMenu/classes.js";
+import { httpCompletions } from "../lib/httpCompletions.js";
+import { jsonRegion } from "./diagnostics.js";
+import { httpContextAt } from "./languages/index.js";
+import { pointerAt } from "./languages/jsonPointers.js";
+import { offsetToPosition } from "./positions.js";
+import { schemaCompletionSource } from "./schema/complete.js";
+const COMPLETION_WORD = /[\w\-/.:]*/;
+const KIND_TO_TYPE = {
+    keyword: 'keyword',
+    property: 'property',
+    value: 'constant',
+    method: 'method',
+    header: 'property',
+    snippet: 'text',
+    text: 'text'
+};
+const COMPLETION_TOOLTIP_CLASS = cn('overflow-hidden rounded-12 border border-border-primary-light! bg-bg-surface-2! p-4', 'font-sans text-text-primary shadow-md');
+const COMPLETION_OPTION_CLASS = cn(dropdownMenuItemVariants({
+    variant: 'default'
+}), 'px-8! py-6!', 'aria-selected:bg-states-primary-hover! aria-selected:text-text-primary!');
+const completionTheme = EditorView.theme({
+    '.cm-tooltip.cm-tooltip-autocomplete > ul': {
+        fontFamily: 'inherit',
+        maxHeight: '240px',
+        minWidth: '200px'
+    },
+    '.cm-tooltip.cm-tooltip-autocomplete > ul > li': {
+        lineHeight: '20px'
+    },
+    '.cm-completionDetail': {
+        marginLeft: 'auto',
+        fontStyle: 'normal',
+        color: 'var(--color-text-secondary)'
+    },
+    '.cm-completionMatchedText': {
+        textDecoration: 'none',
+        fontWeight: '600'
+    },
+    '.cm-tooltip.cm-completionInfo': {
+        padding: '6px 8px'
+    }
+});
+const completionWord = (ctx)=>ctx.matchBefore(COMPLETION_WORD) ?? {
+        from: ctx.pos,
+        text: ''
+    };
+const isJsonLike = (language)=>'json' === language || 'http' === language;
+const jsonPointerAt = (ctx, language)=>{
+    if (!isJsonLike(language)) return;
+    const region = jsonRegion(ctx.state, language);
+    if (!region || ctx.pos < region.from || ctx.pos > region.to) return;
+    return pointerAt(ctx.state, ctx.pos, region);
+};
+const buildCompletionContext = (ctx, language, startingLineNumber)=>{
+    const { doc } = ctx.state;
+    const word = completionWord(ctx);
+    const http = 'http' === language ? httpContextAt(ctx.state, ctx.pos) : void 0;
+    const jsonPointer = jsonPointerAt(ctx, language);
+    return {
+        value: doc.toString(),
+        position: offsetToPosition(doc, ctx.pos, startingLineNumber),
+        lineText: doc.lineAt(ctx.pos).text,
+        word: {
+            text: word.text,
+            from: offsetToPosition(doc, word.from, startingLineNumber)
+        },
+        explicit: ctx.explicit,
+        ...void 0 === http ? {} : {
+            http
+        },
+        ...void 0 === jsonPointer ? {} : {
+            jsonPointer
+        }
+    };
+};
+const toCompletion = (item)=>({
+        label: item.label,
+        apply: item.apply,
+        detail: item.detail,
+        info: item.info,
+        type: void 0 === item.kind ? void 0 : KIND_TO_TYPE[item.kind]
+    });
+let reported = false;
+const reportSourceError = (error)=>{
+    if (!reported) {
+        reported = true;
+        console.error('[CodeEditor] a completion source failed', error);
+    }
+    return null;
+};
+const adaptSource = (source, language, startingLineNumber)=>(ctx)=>{
+        const from = completionWord(ctx).from;
+        const finish = (items)=>items && items.length > 0 ? {
+                from,
+                options: items.map(toCompletion)
+            } : null;
+        try {
+            const result = source(buildCompletionContext(ctx, language, startingLineNumber));
+            return Promise.resolve(result).then(finish, reportSourceError);
+        } catch (error) {
+            return reportSourceError(error);
+        }
+    };
+const reopensAfter = (completion)=>'string' == typeof completion.apply && completion.apply.endsWith(': ');
+const completionExtension = (config)=>{
+    const { language, schema, sources, startingLineNumber } = config;
+    const override = [];
+    if ('http' === language) override.push(adaptSource(httpCompletions, language, startingLineNumber));
+    if (void 0 !== schema && isJsonLike(language)) override.push(schemaCompletionSource(()=>schema, (state)=>jsonRegion(state, language)));
+    for (const source of sources)override.push(adaptSource(source, language, startingLineNumber));
+    if (0 === override.length) return [];
+    return [
+        autocompletion({
+            override,
+            activateOnTyping: true,
+            activateOnCompletion: reopensAfter,
+            defaultKeymap: true,
+            icons: false,
+            tooltipClass: ()=>COMPLETION_TOOLTIP_CLASS,
+            optionClass: ()=>COMPLETION_OPTION_CLASS
+        }),
+        completionTheme
+    ];
+};
+export { buildCompletionContext, completionExtension };

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

@@ -0,0 +1,12 @@
+/**
+ * Attributes CodeMirror sets on `.cm-content` itself. A consumer value would
+ * overwrite them (CM merges only `class` and `style`), breaking the textbox
+ * semantics or the editing surface, so they are never forwarded (spec §9).
+ */
+export declare const RESERVED_CONTENT_ATTRIBUTES: readonly string[];
+/**
+ * Drops reserved keys (with a development warning) and keeps everything else
+ * verbatim — `data-analytics-props` included. `class` is kept: CodeMirror
+ * concatenates it with its own classes instead of replacing them.
+ */
+export declare const sanitizeContentAttributes: (attrs: Record<string, string>) => Record<string, string>;

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

@@ -0,0 +1,24 @@
+const RESERVED_CONTENT_ATTRIBUTES = [
+    'role',
+    'contenteditable',
+    'aria-multiline',
+    'aria-readonly',
+    'spellcheck',
+    'autocorrect',
+    'autocapitalize',
+    'translate',
+    'writingsuggestions'
+];
+const RESERVED = new Set(RESERVED_CONTENT_ATTRIBUTES);
+const sanitizeContentAttributes = (attrs)=>{
+    const result = {};
+    for (const [key, value] of Object.entries(attrs)){
+        if (RESERVED.has(key.toLowerCase())) {
+            if ('production' !== process.env.NODE_ENV) console.warn(`[CodeEditor] "${key}" is managed by the editor and cannot be set on CodeEditorContent; the value "${value}" was ignored.`);
+            continue;
+        }
+        result[key] = value;
+    }
+    return result;
+};
+export { RESERVED_CONTENT_ATTRIBUTES, sanitizeContentAttributes };

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

@@ -0,0 +1,73 @@
+import { type Diagnostic } from '@codemirror/lint';
+import type { EditorState, Extension, Text } from '@codemirror/state';
+import type { CodeEditorDiagnostic, CodeEditorLanguage, JsonSchema } from '../types';
+/** Absolute document range holding JSON (whole doc for `json`, the JSON body for `http`). */
+export interface JsonRegion {
+    from: number;
+    to: number;
+}
+/**
+ * Schema hook (spec §7.13). T13 passes a function that dynamically imports
+ * `./schema/validate` and returns CM diagnostics with absolute offsets.
+ * Called only when `schema` is set and the region is syntactically valid JSON.
+ */
+export type SchemaDiagnosticsSource = (state: EditorState, region: JsonRegion) => Promise<readonly Diagnostic[]>;
+export interface DiagnosticsConfig {
+    language: CodeEditorLanguage;
+    schema: JsonSchema | undefined;
+    external: readonly CodeEditorDiagnostic[];
+    startingLineNumber: number;
+    onChange: (diagnostics: CodeEditorDiagnostic[]) => void;
+    schemaSource?: SchemaDiagnosticsSource;
+}
+/** Linter debounce after a change, in ms (spec §7.12). */
+export declare const LINT_DELAY = 300;
+export declare const SYNTAX_SOURCE = "syntax";
+export declare const SCHEMA_SOURCE = "schema";
+/**
+ * Where the JSON lives in the document: the whole document for `json`, the mounted
+ * `JsonText` body for `http` (null when the body is absent or not JSON), otherwise null.
+ */
+export declare const jsonRegion: (state: EditorState, language: CodeEditorLanguage) => JsonRegion | null;
+export interface JsonSyntaxErrorLocation {
+    /** Offset relative to the parsed text, or null when the message carries no position. */
+    offset: number | null;
+    /** Human-readable message without engine-specific position suffixes. */
+    message: string;
+}
+/**
+ * Reads the error position out of a `JSON.parse` SyntaxError message.
+ * V8: `... in JSON at position N (line L column C)`; Firefox: `... at line L column C of the JSON data`;
+ * `Unexpected end of JSON input` / `unexpected end of data` → end of the content.
+ */
+export declare const locateJsonSyntaxError: (message: string, text: string) => JsonSyntaxErrorLocation;
+/**
+ * Syntax errors from the Lezer tree (spec §14 A3): every error (⚠) node of the parsed tree — or
+ * only those inside `region` — becomes an `error` diagnostic; error nodes that touch are
+ * collapsed into one. If the parse times out, errors at or past the parsed extent (including
+ * "Unexpected end of input") are not reported. Empty for a state without a parser.
+ */
+export declare const syntaxErrorDiagnostics: (state: EditorState, region?: JsonRegion, timeout?: number) => Diagnostic[];
+/** JSON syntax error of the region (at most one — `JSON.parse` stops at the first). */
+export declare const jsonSyntaxDiagnostics: (state: EditorState, region: JsonRegion, timeout?: number) => Diagnostic[];
+/**
+ * Consumer diagnostic → CM diagnostic. `null` when `from.line` is outside the document;
+ * a `to` line outside the document is clamped to the document end.
+ */
+export declare const toCmDiagnostic: (doc: Text, diagnostic: CodeEditorDiagnostic, startingLineNumber: number) => Diagnostic | null;
+/** CM diagnostic → public form (absolute lines, 1-based columns). `hint` reads as `info`. */
+export declare const toPublicDiagnostic: (doc: Text, diagnostic: Diagnostic, startingLineNumber: number) => CodeEditorDiagnostic;
+/**
+ * Underlines per spec §7.10 (existing indicator tokens only) and the lint tooltip on the
+ * DS Tooltip surface (`TooltipContent`: `bg-component-tooltip-bg text-text-primary-alt
+ * text-xs font-medium rounded-8 py-4 px-8`, z-index `--tooltip-z-index`). The surface rule
+ * targets every hover tooltip so schema hover (T13) matches.
+ */
+export declare const diagnosticsTheme: Extension;
+/**
+ * Diagnostics (spec §7.12, §14 A3 + A5): one debounced linter merging syntax errors (JSON.parse for
+ * json / the http JSON body, `@babel/parser` for javascript / typescript, `luaparse` for lua (A6), Lezer error nodes for
+ * yaml / python), schema errors (via `schemaSource`, T13) and the consumer `diagnostics` prop.
+ * Underlines + hover tooltip only — no lint gutter, panel or lint keymap.
+ */
+export declare const diagnosticsExtension: (config: DiagnosticsConfig) => Extension;