@adecore/editor-react 0.31.12 → 0.32.0

package/dist/rendering-context.js

@@ -1,5 +1,7 @@
 import { createContext, useContext } from 'react';
-export const RenderingContext = createContext({ theme: 'light' });
+export const RenderingContext = createContext({
+  theme: 'light'
+});
 export function useEditorRendering() {
-    return useContext(RenderingContext);
-}
+  return useContext(RenderingContext);
+}

package/dist/rendering.js

@@ -1,5 +1,23 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
 import { RenderingContext } from './rendering-context.js';
-export function EditorRenderingProvider({ value, children }) {
-    return _jsx(RenderingContext, { value: value, children: children });
-}
+import { jsx as _jsx } from "react/jsx-runtime";
+export function EditorRenderingProvider(t0) {
+  const $ = _c(3);
+  const {
+    value,
+    children
+  } = t0;
+  let t1;
+  if ($[0] !== children || $[1] !== value) {
+    t1 = /*#__PURE__*/_jsx(RenderingContext, {
+      value: value,
+      children: children
+    });
+    $[0] = children;
+    $[1] = value;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  return t1;
+}

package/dist/review-group.js

@@ -4,47 +4,50 @@
  * change in front of a person that the other already took.
  */
 export class ReviewGroup {
-    members = new Set();
-    join(member) {
-        this.members.add(member);
-        return () => {
-            this.members.delete(member);
-        };
-    }
-    hide(runIds) {
-        this.each((member) => member.hide(runIds));
-    }
-    show(runIds) {
-        this.each((member) => member.show(runIds));
-    }
-    refresh() {
-        this.each((member) => member.refresh());
-    }
-    /* Over a copy, since a member may leave while it hears. */
-    each(action) {
-        for (const member of [...this.members]) {
-            action(member);
-        }
+  members = new Set();
+  join(member) {
+    this.members.add(member);
+    return () => {
+      this.members.delete(member);
+    };
+  }
+  hide(runIds) {
+    this.each(member => member.hide(runIds));
+  }
+  show(runIds) {
+    this.each(member => member.show(runIds));
+  }
+  refresh() {
+    this.each(member => member.refresh());
+  }
+  /* Over a copy, since a member may leave while it hears. */
+  each(action) {
+    for (const member of [...this.members]) {
+      action(member);
     }
+  }
 }
 const groups = new Map();
 /* The host supplies a shared file key; the group is released with its last editor. */
 export function joinReviewGroup(key) {
-    const held = groups.get(key) ?? { group: new ReviewGroup(), holders: 0 };
-    groups.set(key, held);
-    held.holders++;
-    let left = false;
-    return {
-        group: held.group,
-        leave: () => {
-            if (left) {
-                return;
-            }
-            left = true;
-            held.holders--;
-            if (held.holders === 0 && groups.get(key) === held) {
-                groups.delete(key);
-            }
-        }
-    };
-}
+  const held = groups.get(key) ?? {
+    group: new ReviewGroup(),
+    holders: 0
+  };
+  groups.set(key, held);
+  held.holders++;
+  let left = false;
+  return {
+    group: held.group,
+    leave: () => {
+      if (left) {
+        return;
+      }
+      left = true;
+      held.holders--;
+      if (held.holders === 0 && groups.get(key) === held) {
+        groups.delete(key);
+      }
+    }
+  };
+}

package/dist/row-host.d.ts

@@ -18,9 +18,11 @@ declare abstract class ContainerHost {
     private readonly listeners;
     private version;
     private signature;
+    private shown;
     constructor(editor: Editor, owner: string);
-    getVersion: () => number;
-    subscribe: (listener: () => void) => (() => void);
+    getVersion(): number;
+    getContainers(): ReadonlyMap<string, HTMLElement>;
+    subscribe(listener: () => void): () => void;
     container(id: string): HTMLElement | undefined;
     protected replace(signature: string, ids: readonly string[]): boolean;
     protected mounted(id: string, container: HTMLElement): void;

package/dist/row-host.js

@@ -1,49 +1,62 @@
 /* The elements an editor made for one owner's entries, and a version React reads them by. */
 class ContainerHost {
-    editor;
-    owner;
-    containers = new Map();
-    listeners = new Set();
-    version = 0;
-    signature = '';
-    constructor(editor, owner) {
-        this.editor = editor;
-        this.owner = owner;
+  editor;
+  owner;
+  containers = new Map();
+  listeners = new Set();
+  version = 0;
+  signature = '';
+  shown = null;
+  constructor(editor, owner) {
+    this.editor = editor;
+    this.owner = owner;
+  }
+  getVersion() {
+    return this.version;
+  }
+  /* The elements by id as they stand now, one map until they change, so React can read them as a snapshot. */
+  getContainers() {
+    if (this.shown?.version !== this.version) {
+      this.shown = {
+        version: this.version,
+        containers: new Map(this.containers)
+      };
     }
-    getVersion = () => this.version;
-    subscribe = (listener) => {
-        this.listeners.add(listener);
-        return () => {
-            this.listeners.delete(listener);
-        };
+    return this.shown.containers;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
     };
-    container(id) {
-        return this.containers.get(id);
+  }
+  container(id) {
+    return this.containers.get(id);
+  }
+  /* False for the same entries again, so an editor does not measure them twice; otherwise drops the elements of entries that left. */
+  replace(signature, ids) {
+    if (signature === this.signature) {
+      return false;
     }
-    /* False for the same entries again, so an editor does not measure them twice; otherwise drops the elements of entries that left. */
-    replace(signature, ids) {
-        if (signature === this.signature) {
-            return false;
-        }
-        this.signature = signature;
-        const kept = new Set(ids);
-        for (const id of [...this.containers.keys()]) {
-            if (!kept.has(id)) {
-                this.containers.delete(id);
-            }
-        }
-        return true;
+    this.signature = signature;
+    const kept = new Set(ids);
+    for (const id of [...this.containers.keys()]) {
+      if (!kept.has(id)) {
+        this.containers.delete(id);
+      }
     }
-    mounted(id, container) {
-        this.containers.set(id, container);
-        this.bump();
-    }
-    bump() {
-        this.version++;
-        for (const listener of [...this.listeners]) {
-            listener();
-        }
+    return true;
+  }
+  mounted(id, container) {
+    this.containers.set(id, container);
+    this.bump();
+  }
+  bump() {
+    this.version++;
+    for (const listener of [...this.listeners]) {
+      listener();
     }
+  }
 }
 /*
  * The rows of one owner in an editor, and the elements the editor draws them in, so React can portal
@@ -51,31 +64,30 @@ class ContainerHost {
  * row's content never keeps state of its own.
  */
 export class RowHost extends ContainerHost {
-    set(rows) {
-        const signature = rows.map((row) => `${row.id}@${row.line}${row.placement}:${row.height}:${row.fixed}:${row.filler}`).join('|');
-        if (!this.replace(signature, rows.map((row) => row.id))) {
-            return;
-        }
-        this.editor.setWidgets(rows.map((row) => ({
-            id: row.filler ? `${row.id}-filler` : row.id,
-            line: row.line,
-            placement: row.placement,
-            height: row.height,
-            fixed: row.fixed,
-            render: (container) => {
-                if (row.filler) {
-                    container.classList.add('adecore-editor-diff-filler');
-                }
-                else {
-                    this.mounted(row.id, container);
-                }
-            }
-        })), this.owner);
-        this.bump();
-    }
-    clear() {
-        this.set([]);
+  set(rows) {
+    const signature = rows.map(row => `${row.id}@${row.line}${row.placement}:${row.height}:${row.fixed}:${row.filler}`).join('|');
+    if (!this.replace(signature, rows.map(row => row.id))) {
+      return;
     }
+    this.editor.setWidgets(rows.map(row => ({
+      id: row.filler ? `${row.id}-filler` : row.id,
+      line: row.line,
+      placement: row.placement,
+      height: row.height,
+      fixed: row.fixed,
+      render: container => {
+        if (row.filler) {
+          container.classList.add('adecore-editor-diff-filler');
+        } else {
+          this.mounted(row.id, container);
+        }
+      }
+    })), this.owner);
+    this.bump();
+  }
+  clear() {
+    this.set([]);
+  }
 }
 /*
  * The actions of one owner after the end of lines in an editor, and the elements the editor makes for
@@ -83,19 +95,19 @@ export class RowHost extends ContainerHost {
  * its state.
  */
 export class LineActionHost extends ContainerHost {
-    set(actions) {
-        const signature = actions.map((action) => `${action.id}@${action.line}`).join('|');
-        if (!this.replace(signature, actions.map((action) => action.id))) {
-            return;
-        }
-        this.editor.setLineActions(actions.map((action) => ({
-            id: action.id,
-            line: action.line,
-            render: (container) => this.mounted(action.id, container)
-        })), this.owner);
-        this.bump();
+  set(actions) {
+    const signature = actions.map(action => `${action.id}@${action.line}`).join('|');
+    if (!this.replace(signature, actions.map(action => action.id))) {
+      return;
     }
-    clear() {
-        this.set([]);
-    }
-}
+    this.editor.setLineActions(actions.map(action => ({
+      id: action.id,
+      line: action.line,
+      render: container => this.mounted(action.id, container)
+    })), this.owner);
+    this.bump();
+  }
+  clear() {
+    this.set([]);
+  }
+}

package/dist/selection-ranges.js

@@ -1,26 +1,30 @@
 const METHOD = 'textDocument/selectionRange';
 /* The links of one answer, the smallest range first. */
 export function selectionChainOf(selection) {
-    const chain = [];
-    for (let link = selection; link; link = link.parent) {
-        chain.push(link.range);
-    }
-    return chain;
+  const chain = [];
+  for (let link = selection; link; link = link.parent) {
+    chain.push(link.range);
+  }
+  return chain;
 }
 /*
  * Extend and Shrink Selection grow through the ranges the language server knows around the caret, which
  * follow the syntax of the file. Where no server offers them the editor grows by its own rule.
  */
 export class SelectionRangesFeature {
-    constructor(language) {
-        const { editor, project, uri } = language;
-        editor.setSelectionRanges(async (positions) => {
-            if (!project.service.supports(METHOD, uri)) {
-                return null;
-            }
-            const chains = await project.service.selectionRanges(uri, positions);
-            return chains === null || chains.length !== positions.length ? null : chains.map(selectionChainOf);
-        });
-        language.onDispose(() => editor.setSelectionRanges(null));
-    }
-}
+  constructor(language) {
+    const {
+      editor,
+      project,
+      uri
+    } = language;
+    editor.setSelectionRanges(async positions => {
+      if (!project.service.supports(METHOD, uri)) {
+        return null;
+      }
+      const chains = await project.service.selectionRanges(uri, positions);
+      return chains === null || chains.length !== positions.length ? null : chains.map(selectionChainOf);
+    });
+    language.onDispose(() => editor.setSelectionRanges(null));
+  }
+}

package/dist/semantic-delta.js

@@ -4,24 +4,27 @@
  * whole number of tokens. The caller then asks for the full tokens instead. One pass over data and edits.
  */
 export function applySemanticEdits(data, edits) {
-    const result = [];
-    let cursor = 0;
-    for (const edit of edits) {
-        const { start, deleteCount } = edit;
-        const inserted = edit.data ?? [];
-        if (!Number.isInteger(start) || !Number.isInteger(deleteCount) || start < cursor || deleteCount < 0 || start + deleteCount > data.length) {
-            return null;
-        }
-        for (let at = cursor; at < start; at++) {
-            result.push(data[at]);
-        }
-        for (const value of inserted) {
-            result.push(value);
-        }
-        cursor = start + deleteCount;
+  const result = [];
+  let cursor = 0;
+  for (const edit of edits) {
+    const {
+      start,
+      deleteCount
+    } = edit;
+    const inserted = edit.data ?? [];
+    if (!Number.isInteger(start) || !Number.isInteger(deleteCount) || start < cursor || deleteCount < 0 || start + deleteCount > data.length) {
+      return null;
     }
-    for (let at = cursor; at < data.length; at++) {
-        result.push(data[at]);
+    for (let at = cursor; at < start; at++) {
+      result.push(data[at]);
     }
-    return result.length % 5 === 0 ? result : null;
-}
+    for (const value of inserted) {
+      result.push(value);
+    }
+    cursor = start + deleteCount;
+  }
+  for (let at = cursor; at < data.length; at++) {
+    result.push(data[at]);
+  }
+  return result.length % 5 === 0 ? result : null;
+}

package/dist/semantic-model.js

@@ -5,86 +5,99 @@
  * marks what is local to a function, so a variable it leaves unmarked is drawn as a global.
  */
 export function scopesOf(type, modifiers, scoped = false) {
-    switch (type) {
-        case 'namespace':
-            return ['entity.name.namespace'];
-        case 'class':
-            return ['entity.name.type.class'];
-        case 'enum':
-            return ['entity.name.type.enum'];
-        case 'interface':
-            return ['entity.name.type.interface'];
-        case 'struct':
-            return ['entity.name.type.struct'];
-        case 'type':
-            return ['entity.name.type'];
-        case 'typeParameter':
-            return ['entity.name.type.parameter'];
-        case 'parameter':
-            return ['variable.parameter'];
-        case 'property':
-            return [modifiers.has('static') ? 'variable.other.property.static' : 'variable.other.property'];
-        case 'enumMember':
-            return ['variable.other.enummember'];
-        case 'function':
-        case 'method':
-            if (modifiers.has('static')) {
-                return ['entity.name.function.static'];
-            }
-            if (modifiers.has('declaration')) {
-                return ['entity.name.function'];
-            }
-            return [type === 'method' ? 'entity.name.function.method' : 'entity.name.function.call'];
-        case 'decorator':
-            return ['meta.decorator'];
-        case 'macro':
-            return ['entity.name.function.macro'];
-        case 'variable':
-            if (scoped) {
-                return modifiers.has('local') ? null : ['variable.other.constant'];
-            }
-            return modifiers.has('readonly') ? ['variable.other.constant'] : null;
-        default:
-            return null;
-    }
+  switch (type) {
+    case 'namespace':
+      return ['entity.name.namespace'];
+    case 'class':
+      return ['entity.name.type.class'];
+    case 'enum':
+      return ['entity.name.type.enum'];
+    case 'interface':
+      return ['entity.name.type.interface'];
+    case 'struct':
+      return ['entity.name.type.struct'];
+    case 'type':
+      return ['entity.name.type'];
+    case 'typeParameter':
+      return ['entity.name.type.parameter'];
+    case 'parameter':
+      return ['variable.parameter'];
+    case 'property':
+      return [modifiers.has('static') ? 'variable.other.property.static' : 'variable.other.property'];
+    case 'enumMember':
+      return ['variable.other.enummember'];
+    case 'function':
+    case 'method':
+      if (modifiers.has('static')) {
+        return ['entity.name.function.static'];
+      }
+      if (modifiers.has('declaration')) {
+        return ['entity.name.function'];
+      }
+      return [type === 'method' ? 'entity.name.function.method' : 'entity.name.function.call'];
+    case 'decorator':
+      return ['meta.decorator'];
+    case 'macro':
+      return ['entity.name.function.macro'];
+    case 'variable':
+      if (scoped) {
+        return modifiers.has('local') ? null : ['variable.other.constant'];
+      }
+      return modifiers.has('readonly') ? ['variable.other.constant'] : null;
+    default:
+      return null;
+  }
 }
 /*
  * What a server sends for the language it reads inside a string (SQL in a PHP string). Outside a string the grammar
  * colors these better, so they only apply where the grammar says it is a string.
  */
 const EMBEDDED_SCOPES = {
-    keyword: ['keyword'],
-    string: ['string'],
-    number: ['constant.numeric'],
-    comment: ['comment'],
-    operator: ['keyword.operator']
+  keyword: ['keyword'],
+  string: ['string'],
+  number: ['constant.numeric'],
+  comment: ['comment'],
+  operator: ['keyword.operator']
 };
 /* The encoded data of `textDocument/semanticTokens` as one token per classified range, the ones the theme has nothing to say about left out. */
 export function decodeSemanticTokens(tokens, legend) {
-    const result = [];
-    const { data } = tokens;
-    const scoped = legend.tokenModifiers.includes('local');
-    let line = 0;
-    let character = 0;
-    for (let at = 0; at + 4 < data.length; at += 5) {
-        const deltaLine = data[at];
-        line += deltaLine;
-        character = deltaLine === 0 ? character + data[at + 1] : data[at + 1];
-        const type = legend.tokenTypes[data[at + 3]];
-        if (type === undefined) {
-            continue;
-        }
-        const bits = data[at + 4];
-        const modifiers = new Set(legend.tokenModifiers.filter((_, index) => (bits & (1 << index)) !== 0));
-        const scopes = scopesOf(type, modifiers, scoped);
-        if (scopes !== null) {
-            result.push({ line, character, length: data[at + 2], scopes });
-            continue;
-        }
-        const embedded = EMBEDDED_SCOPES[type];
-        if (embedded !== undefined) {
-            result.push({ line, character, length: data[at + 2], scopes: embedded, within: 'string' });
-        }
+  const result = [];
+  const {
+    data
+  } = tokens;
+  const scoped = legend.tokenModifiers.includes('local');
+  let line = 0;
+  let character = 0;
+  for (let at = 0; at + 4 < data.length; at += 5) {
+    const deltaLine = data[at];
+    line += deltaLine;
+    character = deltaLine === 0 ? character + data[at + 1] : data[at + 1];
+    const type = legend.tokenTypes[data[at + 3]];
+    if (type === undefined) {
+      continue;
     }
-    return result;
-}
+    const bits = data[at + 4];
+    const modifiers = new Set(legend.tokenModifiers.filter((_, index) => (bits & 1 << index) !== 0));
+    const scopes = scopesOf(type, modifiers, scoped);
+    if (scopes !== null) {
+      result.push({
+        line,
+        character,
+        length: data[at + 2],
+        scopes
+      });
+      continue;
+    }
+    const embedded = EMBEDDED_SCOPES[type];
+    if (embedded !== undefined) {
+      result.push({
+        line,
+        character,
+        length: data[at + 2],
+        scopes: embedded,
+        within: 'string'
+      });
+    }
+  }
+  return result;
+}