@codemirror/language 6.7.0 → 6.9.0

package/dist/index.d.ts

@@ -587,6 +587,11 @@ declare class TreeIndentContext extends IndentContext {
     */
     get baseIndent(): number;
     /**
+    Get the indentation for the reference line of the given node
+    (see [`baseIndent`](https://codemirror.net/6/docs/ref/#language.TreeIndentContext.baseIndent)).
+    */
+    baseIndentFor(node: SyntaxNode): number;
+    /**
     Continue looking for indentations in the node's parent nodes,
     and return the result of that.
     */
@@ -684,7 +689,7 @@ declare function foldable(state: EditorState, lineStart: number, lineEnd: number
     from: number;
     to: number;
 } | null;
-type DocRange = {
+declare type DocRange = {
     from: number;
     to: number;
 };
@@ -756,23 +761,36 @@ interface FoldConfig {
     position of folded code. The `onclick` argument is the default
     click event handler, which toggles folding on the line that
     holds the element, and should probably be added as an event
-    handler to the returned element.
+    handler to the returned element. If
+    [`preparePlaceholder`](https://codemirror.net/6/docs/ref/#language.FoldConfig.preparePlaceholder)
+    is given, its result will be passed as 3rd argument. Otherwise,
+    this will be null.
     
     When this option isn't given, the `placeholderText` option will
     be used to create the placeholder element.
     */
-    placeholderDOM?: ((view: EditorView, onclick: (event: Event) => void) => HTMLElement) | null;
+    placeholderDOM?: ((view: EditorView, onclick: (event: Event) => void, prepared: any) => HTMLElement) | null;
     /**
     Text to use as placeholder for folded text. Defaults to `"…"`.
     Will be styled with the `"cm-foldPlaceholder"` class.
     */
     placeholderText?: string;
+    /**
+    Given a range that is being folded, create a value that
+    describes it, to be used by `placeholderDOM` to render a custom
+    widget that, for example, indicates something about the folded
+    range's size or type.
+    */
+    preparePlaceholder?: (state: EditorState, range: {
+        from: number;
+        to: number;
+    }) => any;
 }
 /**
 Create an extension that configures code folding.
 */
 declare function codeFolding(config?: FoldConfig): Extension;
-type Handlers = {
+declare type Handlers = {
     [event: string]: (view: EditorView, line: BlockInfo, event: Event) => boolean;
 };
 interface FoldGutterConfig {

package/dist/index.js

@@ -1,4 +1,4 @@
-import { NodeProp, IterMode, Tree, TreeFragment, Parser, NodeType, NodeSet } from '@lezer/common';
+import { NodeProp, Tree, IterMode, TreeFragment, Parser, NodeType, NodeSet } from '@lezer/common';
 import { StateEffect, StateField, Facet, EditorState, countColumn, combineConfig, RangeSet, RangeSetBuilder, Prec } from '@codemirror/state';
 import { ViewPlugin, logException, EditorView, Decoration, WidgetType, gutter, GutterMarker } from '@codemirror/view';
 import { tags, tagHighlighter, highlightTree, styleTags } from '@lezer/highlight';
@@ -534,14 +534,14 @@ class LanguageState {
         // state updates with parse work beyond the viewport.
         let upto = this.context.treeLen == tr.startState.doc.length ? undefined
             : Math.max(tr.changes.mapPos(this.context.treeLen), newCx.viewport.to);
-        if (!newCx.work(20 /* Work.Apply */, upto))
+        if (!newCx.work(20 /* Apply */, upto))
             newCx.takeTree();
         return new LanguageState(newCx);
     }
     static init(state) {
-        let vpTo = Math.min(3000 /* Work.InitViewport */, state.doc.length);
+        let vpTo = Math.min(3000 /* InitViewport */, state.doc.length);
         let parseState = ParseContext.create(state.facet(language).parser, state, { from: 0, to: vpTo });
-        if (!parseState.work(20 /* Work.Apply */, vpTo))
+        if (!parseState.work(20 /* Apply */, vpTo))
             parseState.takeTree();
         return new LanguageState(parseState);
     }
@@ -558,14 +558,14 @@ Language.state = /*@__PURE__*/StateField.define({
     }
 });
 let requestIdle = (callback) => {
-    let timeout = setTimeout(() => callback(), 500 /* Work.MaxPause */);
+    let timeout = setTimeout(() => callback(), 500 /* MaxPause */);
     return () => clearTimeout(timeout);
 };
 if (typeof requestIdleCallback != "undefined")
     requestIdle = (callback) => {
         let idle = -1, timeout = setTimeout(() => {
-            idle = requestIdleCallback(callback, { timeout: 500 /* Work.MaxPause */ - 100 /* Work.MinPause */ });
-        }, 100 /* Work.MinPause */);
+            idle = requestIdleCallback(callback, { timeout: 500 /* MaxPause */ - 100 /* MinPause */ });
+        }, 100 /* MinPause */);
         return () => idle < 0 ? clearTimeout(timeout) : cancelIdleCallback(idle);
     };
 const isInputPending = typeof navigator != "undefined" && ((_a = navigator.scheduling) === null || _a === void 0 ? void 0 : _a.isInputPending)
@@ -588,7 +588,7 @@ const parseWorker = /*@__PURE__*/ViewPlugin.fromClass(class ParseWorker {
             this.scheduleWork();
         if (update.docChanged) {
             if (this.view.hasFocus)
-                this.chunkBudget += 50 /* Work.ChangeBonus */;
+                this.chunkBudget += 50 /* ChangeBonus */;
             this.scheduleWork();
         }
         this.checkAsyncSchedule(cx);
@@ -604,19 +604,19 @@ const parseWorker = /*@__PURE__*/ViewPlugin.fromClass(class ParseWorker {
         this.working = null;
         let now = Date.now();
         if (this.chunkEnd < now && (this.chunkEnd < 0 || this.view.hasFocus)) { // Start a new chunk
-            this.chunkEnd = now + 30000 /* Work.ChunkTime */;
-            this.chunkBudget = 3000 /* Work.ChunkBudget */;
+            this.chunkEnd = now + 30000 /* ChunkTime */;
+            this.chunkBudget = 3000 /* ChunkBudget */;
         }
         if (this.chunkBudget <= 0)
             return; // No more budget
         let { state, viewport: { to: vpTo } } = this.view, field = state.field(Language.state);
-        if (field.tree == field.context.tree && field.context.isDone(vpTo + 100000 /* Work.MaxParseAhead */))
+        if (field.tree == field.context.tree && field.context.isDone(vpTo + 100000 /* MaxParseAhead */))
             return;
-        let endTime = Date.now() + Math.min(this.chunkBudget, 100 /* Work.Slice */, deadline && !isInputPending ? Math.max(25 /* Work.MinSlice */, deadline.timeRemaining() - 5) : 1e9);
+        let endTime = Date.now() + Math.min(this.chunkBudget, 100 /* Slice */, deadline && !isInputPending ? Math.max(25 /* MinSlice */, deadline.timeRemaining() - 5) : 1e9);
         let viewportFirst = field.context.treeLen < vpTo && state.doc.length > vpTo + 1000;
         let done = field.context.work(() => {
             return isInputPending && isInputPending() || Date.now() > endTime;
-        }, vpTo + (viewportFirst ? 0 : 100000 /* Work.MaxParseAhead */));
+        }, vpTo + (viewportFirst ? 0 : 100000 /* MaxParseAhead */));
         this.chunkBudget -= Date.now() - now;
         if (done || this.chunkBudget <= 0) {
             field.context.takeTree();
@@ -861,7 +861,7 @@ function getIndentation(context, pos) {
             return result;
     }
     let tree = syntaxTree(context.state);
-    return tree ? syntaxIndentation(context, tree, pos) : null;
+    return tree.length >= pos ? syntaxIndentation(context, tree, pos) : null;
 }
 /**
 Create a change set that auto-indents all lines touched by the
@@ -1058,13 +1058,20 @@ class TreeIndentContext extends IndentContext {
     on if it is covered by another such node.
     */
     get baseIndent() {
-        let line = this.state.doc.lineAt(this.node.from);
+        return this.baseIndentFor(this.node);
+    }
+    /**
+    Get the indentation for the reference line of the given node
+    (see [`baseIndent`](https://codemirror.net/6/docs/ref/#language.TreeIndentContext.baseIndent)).
+    */
+    baseIndentFor(node) {
+        let line = this.state.doc.lineAt(node.from);
         // Skip line starts that are covered by a sibling (or cousin, etc)
         for (;;) {
-            let atBreak = this.node.resolve(line.from);
+            let atBreak = node.resolve(line.from);
             while (atBreak.parent && atBreak.parent.from == atBreak.from)
                 atBreak = atBreak.parent;
-            if (isParent(atBreak, this.node))
+            if (isParent(atBreak, node))
                 break;
             line = this.state.doc.lineAt(atBreak.from);
         }
@@ -1293,11 +1300,16 @@ const foldState = /*@__PURE__*/StateField.define({
     update(folded, tr) {
         folded = folded.map(tr.changes);
         for (let e of tr.effects) {
-            if (e.is(foldEffect) && !foldExists(folded, e.value.from, e.value.to))
-                folded = folded.update({ add: [foldWidget.range(e.value.from, e.value.to)] });
-            else if (e.is(unfoldEffect))
+            if (e.is(foldEffect) && !foldExists(folded, e.value.from, e.value.to)) {
+                let { preparePlaceholder } = tr.state.facet(foldConfig);
+                let widget = !preparePlaceholder ? foldWidget :
+                    Decoration.replace({ widget: new PreparedFoldWidget(preparePlaceholder(tr.state, e.value)) });
+                folded = folded.update({ add: [widget.range(e.value.from, e.value.to)] });
+            }
+            else if (e.is(unfoldEffect)) {
                 folded = folded.update({ filter: (from, to) => e.value.from != from || e.value.to != to,
                     filterFrom: e.value.from, filterTo: e.value.to });
+            }
         }
         // Clear folded ranges that cover the selection head
         if (tr.selection) {
@@ -1474,6 +1486,7 @@ const foldKeymap = [
 ];
 const defaultConfig = {
     placeholderDOM: null,
+    preparePlaceholder: null,
     placeholderText: "…"
 };
 const foldConfig = /*@__PURE__*/Facet.define({
@@ -1488,27 +1501,36 @@ function codeFolding(config) {
         result.push(foldConfig.of(config));
     return result;
 }
+function widgetToDOM(view, prepared) {
+    let { state } = view, conf = state.facet(foldConfig);
+    let onclick = (event) => {
+        let line = view.lineBlockAt(view.posAtDOM(event.target));
+        let folded = findFold(view.state, line.from, line.to);
+        if (folded)
+            view.dispatch({ effects: unfoldEffect.of(folded) });
+        event.preventDefault();
+    };
+    if (conf.placeholderDOM)
+        return conf.placeholderDOM(view, onclick, prepared);
+    let element = document.createElement("span");
+    element.textContent = conf.placeholderText;
+    element.setAttribute("aria-label", state.phrase("folded code"));
+    element.title = state.phrase("unfold");
+    element.className = "cm-foldPlaceholder";
+    element.onclick = onclick;
+    return element;
+}
 const foldWidget = /*@__PURE__*/Decoration.replace({ widget: /*@__PURE__*/new class extends WidgetType {
-        toDOM(view) {
-            let { state } = view, conf = state.facet(foldConfig);
-            let onclick = (event) => {
-                let line = view.lineBlockAt(view.posAtDOM(event.target));
-                let folded = findFold(view.state, line.from, line.to);
-                if (folded)
-                    view.dispatch({ effects: unfoldEffect.of(folded) });
-                event.preventDefault();
-            };
-            if (conf.placeholderDOM)
-                return conf.placeholderDOM(view, onclick);
-            let element = document.createElement("span");
-            element.textContent = conf.placeholderText;
-            element.setAttribute("aria-label", state.phrase("folded code"));
-            element.title = state.phrase("unfold");
-            element.className = "cm-foldPlaceholder";
-            element.onclick = onclick;
-            return element;
-        }
+        toDOM(view) { return widgetToDOM(view, null); }
     } });
+class PreparedFoldWidget extends WidgetType {
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    eq(other) { return this.value == other.value; }
+    toDOM(view) { return widgetToDOM(view, this.value); }
+}
 const foldGutterDefaults = {
     openText: "⌄",
     closedText: "›",
@@ -2196,7 +2218,7 @@ class StreamLanguage extends Language {
             state = this.streamParser.startState(cx.unit);
             statePos = 0;
         }
-        if (pos - statePos > 10000 /* C.MaxIndentScanDist */)
+        if (pos - statePos > 10000 /* MaxIndentScanDist */)
             return null;
         while (statePos < pos) {
             let line = cx.state.doc.lineAt(statePos), end = Math.min(pos, line.to);
@@ -2278,7 +2300,7 @@ class Parse {
             this.chunks.push(tree.children[i]);
             this.chunkPos.push(tree.positions[i]);
         }
-        if (context && this.parsedPos < context.viewport.from - 100000 /* C.MaxDistanceBeforeViewport */) {
+        if (context && this.parsedPos < context.viewport.from - 100000 /* MaxDistanceBeforeViewport */) {
             this.state = this.lang.streamParser.startState(getIndentUnit(context.state));
             context.skipUntilInView(this.parsedPos, context.viewport.from);
             this.parsedPos = context.viewport.from;
@@ -2288,7 +2310,7 @@ class Parse {
     advance() {
         let context = ParseContext.get();
         let parseEnd = this.stoppedAt == null ? this.to : Math.min(this.to, this.stoppedAt);
-        let end = Math.min(parseEnd, this.chunkStart + 2048 /* C.ChunkSize */);
+        let end = Math.min(parseEnd, this.chunkStart + 2048 /* ChunkSize */);
         if (context)
             end = Math.min(end, context.viewport.to);
         while (this.parsedPos < end)
@@ -2372,7 +2394,7 @@ class Parse {
                 let token = readToken(streamParser.token, stream, this.state);
                 if (token)
                     offset = this.emitToken(this.lang.tokenTable.resolve(token), this.parsedPos + stream.start, this.parsedPos + stream.pos, 4, offset);
-                if (stream.start > 10000 /* C.MaxLineLength */)
+                if (stream.start > 10000 /* MaxLineLength */)
                     break;
             }
         }
@@ -2388,7 +2410,7 @@ class Parse {
             length: this.parsedPos - this.chunkStart,
             nodeSet,
             topID: 0,
-            maxBufferLength: 2048 /* C.ChunkSize */,
+            maxBufferLength: 2048 /* ChunkSize */,
             reused: this.chunkReused
         });
         tree = new Tree(tree.type, tree.children, tree.positions, tree.length, [[this.lang.stateAfter, this.lang.streamParser.copyState(this.state)]]);
@@ -2478,7 +2500,7 @@ function createTokenType(extra, tagStr) {
     return type.id;
 }
 function docID(data) {
-    let type = NodeType.define({ id: typeArray.length, name: "Document", props: [languageDataProp.add(() => data)] });
+    let type = NodeType.define({ id: typeArray.length, name: "Document", props: [languageDataProp.add(() => data)], top: true });
     typeArray.push(type);
     return type;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemirror/language",
-  "version": "6.7.0",
+  "version": "6.9.0",
   "description": "Language support infrastructure for the CodeMirror code editor",
   "scripts": {
     "test": "cm-runtests",
@@ -34,7 +34,7 @@
     "style-mod": "^4.0.0"
   },
   "devDependencies": {
-    "@codemirror/buildhelper": "^0.1.5",
+    "@codemirror/buildhelper": "^1.0.0",
     "@lezer/javascript": "^1.0.0"
   },
   "repository": {