@adecore/editor-react 0.31.12 → 0.32.0

package/dist/split-alignment.js

@@ -1,38 +1,50 @@
 /* Intrinsic heights exclude spacers, so repeated alignment converges without adding its own padding. */
 export function splitAlignment(aligned, oldHeight, newHeight, gapHeight = 32) {
-    const rows = { old: [], new: [] };
-    const previous = { old: -1, new: -1 };
-    const add = (side, index, height, gap) => {
-        if (height <= 0) {
-            return;
-        }
-        const line = Math.max(0, previous[side]);
-        const placement = previous[side] < 0 ? 'above' : 'below';
-        const last = rows[side].at(-1);
-        if (gap === undefined && last?.filler && last.line === line && last.placement === placement) {
-            last.height += height;
-        }
-        else {
-            rows[side].push({ id: gap === undefined ? `spacer-${index}` : `gap-${gap}`, line, placement, height, fixed: true, filler: gap === undefined });
-        }
-    };
-    for (const [index, entry] of aligned.entries()) {
-        if (entry.kind === 'gap') {
-            add('old', index, gapHeight, entry.row.id);
-            add('new', index, gapHeight, entry.row.id);
-            continue;
-        }
-        const old = entry.old === undefined ? 0 : oldHeight(entry.old);
-        const fresh = entry.new === undefined ? 0 : newHeight(entry.new);
-        if (entry.old !== undefined) {
-            previous.old = entry.old;
-        }
-        if (entry.new !== undefined) {
-            previous.new = entry.new;
-        }
-        const target = Math.max(old, fresh);
-        add('old', index, target - old);
-        add('new', index, target - fresh);
+  const rows = {
+    old: [],
+    new: []
+  };
+  const previous = {
+    old: -1,
+    new: -1
+  };
+  const add = (side, index, height, gap) => {
+    if (height <= 0) {
+      return;
     }
-    return rows;
-}
+    const line = Math.max(0, previous[side]);
+    const placement = previous[side] < 0 ? 'above' : 'below';
+    const last = rows[side].at(-1);
+    if (gap === undefined && last?.filler && last.line === line && last.placement === placement) {
+      last.height += height;
+    } else {
+      rows[side].push({
+        id: gap === undefined ? `spacer-${index}` : `gap-${gap}`,
+        line,
+        placement,
+        height,
+        fixed: true,
+        filler: gap === undefined
+      });
+    }
+  };
+  for (const [index, entry] of aligned.entries()) {
+    if (entry.kind === 'gap') {
+      add('old', index, gapHeight, entry.row.id);
+      add('new', index, gapHeight, entry.row.id);
+      continue;
+    }
+    const old = entry.old === undefined ? 0 : oldHeight(entry.old);
+    const fresh = entry.new === undefined ? 0 : newHeight(entry.new);
+    if (entry.old !== undefined) {
+      previous.old = entry.old;
+    }
+    if (entry.new !== undefined) {
+      previous.new = entry.new;
+    }
+    const target = Math.max(old, fresh);
+    add('old', index, target - old);
+    add('new', index, target - fresh);
+  }
+  return rows;
+}

package/dist/split-scroll.js

@@ -1,45 +1,47 @@
 export class SplitScroll {
-    leader = 'new';
-    syncing = false;
-    expected;
-    editors;
-    constructor(editors) {
-        this.editors = editors;
-        this.expected = { old: editors.old.getScrollTop(), new: editors.new.getScrollTop() };
+  leader = 'new';
+  syncing = false;
+  expected;
+  editors;
+  constructor(editors) {
+    this.editors = editors;
+    this.expected = {
+      old: editors.old.getScrollTop(),
+      new: editors.new.getScrollTop()
+    };
+  }
+  drive(side) {
+    this.leader = side;
+  }
+  changed(side) {
+    if (this.syncing) {
+      return;
     }
-    drive(side) {
-        this.leader = side;
+    const top = this.editors[side].getScrollTop();
+    if (side !== this.leader) {
+      // Native scroll echoes arrive after setScrollTop returns, including a clamped follower position.
+      if (Math.abs(top - this.expected[side]) < 1) {
+        return;
+      }
+      this.leader = side;
     }
-    changed(side) {
-        if (this.syncing) {
-            return;
-        }
-        const top = this.editors[side].getScrollTop();
-        if (side !== this.leader) {
-            // Native scroll echoes arrive after setScrollTop returns, including a clamped follower position.
-            if (Math.abs(top - this.expected[side]) < 1) {
-                return;
-            }
-            this.leader = side;
-        }
-        this.sync();
+    this.sync();
+  }
+  sync() {
+    const side = this.leader;
+    const other = side === 'old' ? 'new' : 'old';
+    const top = this.editors[side].getScrollTop();
+    this.expected[side] = top;
+    if (Math.abs(this.editors[other].getScrollTop() - top) < 1) {
+      this.expected[other] = this.editors[other].getScrollTop();
+      return;
     }
-    sync() {
-        const side = this.leader;
-        const other = side === 'old' ? 'new' : 'old';
-        const top = this.editors[side].getScrollTop();
-        this.expected[side] = top;
-        if (Math.abs(this.editors[other].getScrollTop() - top) < 1) {
-            this.expected[other] = this.editors[other].getScrollTop();
-            return;
-        }
-        this.syncing = true;
-        try {
-            this.editors[other].setScrollTop(top);
-        }
-        finally {
-            this.expected[other] = this.editors[other].getScrollTop();
-            this.syncing = false;
-        }
+    this.syncing = true;
+    try {
+      this.editors[other].setScrollTop(top);
+    } finally {
+      this.expected[other] = this.editors[other].getScrollTop();
+      this.syncing = false;
     }
-}
+  }
+}

package/dist/symbol-links.js

@@ -3,19 +3,19 @@ export const SYMBOL_LINK_CLASS = 'cursor-pointer hover:text-accent hover:underli
 const TYPE_NAME = /^[A-Z][A-Za-z0-9_]*$/;
 /* A name that starts with a capital and has a lowercase letter, which leaves `DEFAULT_WEIGHTS` and `T` alone. */
 export function isTypeName(name) {
-    return TYPE_NAME.test(name) && /[a-z]/.test(name);
+  return TYPE_NAME.test(name) && /[a-z]/.test(name);
 }
 /*
  * Marks the type-like names of a highlighted snippet as links. Shiki writes each token as a span of its own,
  * so a name that is the whole text of a token is one; a string or a comment is never that.
  */
 export function linkTypeNames(html) {
-    return html.replace(/>([A-Z][A-Za-z0-9_]*)</g, (match, name) => isTypeName(name) ? `><span data-symbol="${name}" class="${SYMBOL_LINK_CLASS}">${name}</span><` : match);
+  return html.replace(/>([A-Z][A-Za-z0-9_]*)</g, (match, name) => isTypeName(name) ? `><span data-symbol="${name}" class="${SYMBOL_LINK_CLASS}">${name}</span><` : match);
 }
 const DECLARES = /\b(?:class|interface|enum|trait|type|namespace|struct|function|const|let|var)\s+&?([A-Za-z_$][\w$]*)/;
 /* The name a signature declares, such as `IssueTicketsMessage` in `final class IssueTicketsMessage implements MessageInterface`; null for one that declares nothing, such as a method of a class. */
 export function declaredNameOf(code) {
-    return DECLARES.exec(code)?.[1] ?? null;
+  return DECLARES.exec(code)?.[1] ?? null;
 }
 /* The symbol kinds a type name can mean: module, namespace, class, enum, interface, struct and type parameter. */
 const TYPE_KINDS = new Set([2, 3, 5, 10, 11, 23, 26]);
@@ -25,26 +25,34 @@ const TYPE_KINDS = new Set([2, 3, 5, 10, 11, 23, 26]);
  * namespace) the current file names, which is how a file says which `Message` it means.
  */
 export function placesOfName(result, name, fileText) {
-    const found = (result ?? []).filter((symbol) => symbol.name === name);
-    const types = found.filter((symbol) => TYPE_KINDS.has(symbol.kind));
-    let candidates = types.length > 0 ? types : found;
-    if (candidates.length > 1) {
-        const named = candidates.filter((symbol) => symbol.containerName !== undefined && symbol.containerName !== '' && fileText.includes(symbol.containerName));
-        if (named.length > 0) {
-            candidates = named;
-        }
+  const found = (result ?? []).filter(symbol => symbol.name === name);
+  const types = found.filter(symbol => TYPE_KINDS.has(symbol.kind));
+  let candidates = types.length > 0 ? types : found;
+  if (candidates.length > 1) {
+    const named = candidates.filter(symbol => symbol.containerName !== undefined && symbol.containerName !== '' && fileText.includes(symbol.containerName));
+    if (named.length > 0) {
+      candidates = named;
     }
-    const seen = new Set();
-    return candidates
-        .map((symbol) => 'range' in symbol.location
-        ? symbol.location
-        : { uri: symbol.location.uri, range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } } })
-        .filter((location) => {
-        const key = `${location.uri}\0${location.range.start.line}`;
-        if (seen.has(key)) {
-            return false;
-        }
-        seen.add(key);
-        return true;
-    });
-}
+  }
+  const seen = new Set();
+  return candidates.map(symbol => 'range' in symbol.location ? symbol.location : {
+    uri: symbol.location.uri,
+    range: {
+      start: {
+        line: 0,
+        character: 0
+      },
+      end: {
+        line: 0,
+        character: 0
+      }
+    }
+  }).filter(location => {
+    const key = `${location.uri}\0${location.range.start.line}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}

package/dist/symbol-picker-model.js

@@ -1,152 +1,162 @@
 /* The order the groups are listed in: what a file declares, then what those declare. */
-export const SYMBOL_GROUPS = [
-    'namespaces',
-    'classes',
-    'interfaces',
-    'enums',
-    'functions',
-    'methods',
-    'properties',
-    'variables',
-    'constants',
-    'other'
-];
+export const SYMBOL_GROUPS = ['namespaces', 'classes', 'interfaces', 'enums', 'functions', 'methods', 'properties', 'variables', 'constants', 'other'];
 const GROUP_OF_KIND = {
-    2: 'namespaces',
-    3: 'namespaces',
-    4: 'namespaces',
-    5: 'classes',
-    23: 'classes',
-    11: 'interfaces',
-    10: 'enums',
-    22: 'enums',
-    12: 'functions',
-    6: 'methods',
-    9: 'methods',
-    7: 'properties',
-    8: 'properties',
-    13: 'variables',
-    14: 'constants',
-    26: 'other'
+  2: 'namespaces',
+  3: 'namespaces',
+  4: 'namespaces',
+  5: 'classes',
+  23: 'classes',
+  11: 'interfaces',
+  10: 'enums',
+  22: 'enums',
+  12: 'functions',
+  6: 'methods',
+  9: 'methods',
+  7: 'properties',
+  8: 'properties',
+  13: 'variables',
+  14: 'constants',
+  26: 'other'
 };
 export function groupOfKind(kind) {
-    return GROUP_OF_KIND[kind] ?? 'other';
+  return GROUP_OF_KIND[kind] ?? 'other';
 }
 const ENUM_MEMBER = 22;
 const LETTERS = {
-    namespaces: 'N',
-    classes: 'C',
-    interfaces: 'I',
-    enums: 'E',
-    functions: 'f',
-    methods: 'm',
-    properties: 'p',
-    variables: 'v',
-    constants: 'c',
-    other: '·'
+  namespaces: 'N',
+  classes: 'C',
+  interfaces: 'I',
+  enums: 'E',
+  functions: 'f',
+  methods: 'm',
+  properties: 'p',
+  variables: 'v',
+  constants: 'c',
+  other: '·'
 };
 /* The letter in the badge in front of a symbol. */
 export function letterOfKind(kind) {
-    return kind === ENUM_MEMBER ? 'e' : LETTERS[groupOfKind(kind)];
+  return kind === ENUM_MEMBER ? 'e' : LETTERS[groupOfKind(kind)];
 }
 const TONES = {
-    namespaces: 'other',
-    classes: 'type',
-    interfaces: 'type',
-    enums: 'type',
-    functions: 'callable',
-    methods: 'callable',
-    properties: 'value',
-    variables: 'value',
-    constants: 'value',
-    other: 'other'
+  namespaces: 'other',
+  classes: 'type',
+  interfaces: 'type',
+  enums: 'type',
+  functions: 'callable',
+  methods: 'callable',
+  properties: 'value',
+  variables: 'value',
+  constants: 'value',
+  other: 'other'
 };
 export function toneOfKind(kind) {
-    return TONES[groupOfKind(kind)];
+  return TONES[groupOfKind(kind)];
 }
 function isHierarchical(symbols) {
-    return symbols.length > 0 && 'selectionRange' in symbols[0];
+  return symbols.length > 0 && 'selectionRange' in symbols[0];
 }
 /* The symbols of a file, parents before their children, in the order of the file. */
 export function entriesOf(result) {
-    const entries = [];
-    const add = (name, kind, container, detail, at) => {
-        entries.push({ id: String(entries.length), name, kind, container, detail, line: at.line, character: at.character });
-    };
-    const walk = (symbols, container) => {
-        for (const symbol of symbols) {
-            add(symbol.name, symbol.kind, container, symbol.detail ?? '', symbol.selectionRange.start);
-            walk(symbol.children ?? [], container === '' ? symbol.name : `${container}.${symbol.name}`);
-        }
-    };
-    if (result === null || result.length === 0) {
-        return entries;
-    }
-    if (isHierarchical(result)) {
-        walk(result, '');
-    }
-    else {
-        for (const symbol of result) {
-            add(symbol.name, symbol.kind, symbol.containerName ?? '', '', symbol.location.range.start);
-        }
+  const entries = [];
+  const add = (name, kind, container, detail, at) => {
+    entries.push({
+      id: String(entries.length),
+      name,
+      kind,
+      container,
+      detail,
+      line: at.line,
+      character: at.character
+    });
+  };
+  const walk = (symbols, container) => {
+    for (const symbol of symbols) {
+      add(symbol.name, symbol.kind, container, symbol.detail ?? '', symbol.selectionRange.start);
+      walk(symbol.children ?? [], container === '' ? symbol.name : `${container}.${symbol.name}`);
     }
+  };
+  if (result === null || result.length === 0) {
     return entries;
+  }
+  if (isHierarchical(result)) {
+    walk(result, '');
+  } else {
+    for (const symbol of result) {
+      add(symbol.name, symbol.kind, symbol.containerName ?? '', '', symbol.location.range.start);
+    }
+  }
+  return entries;
 }
 /* How well a query matches a name: 3 for a prefix, 2 for a part of it, 1 for its letters in order, 0 for no match. Case is ignored. */
 export function scoreOf(name, query) {
-    const haystack = name.toLowerCase();
-    const needle = query.toLowerCase();
-    if (needle === '') {
-        return 1;
-    }
-    if (haystack.startsWith(needle)) {
-        return 3;
-    }
-    if (haystack.includes(needle)) {
-        return 2;
-    }
-    let from = 0;
-    for (const character of needle) {
-        from = haystack.indexOf(character, from) + 1;
-        if (from === 0) {
-            return 0;
-        }
-    }
+  const haystack = name.toLowerCase();
+  const needle = query.toLowerCase();
+  if (needle === '') {
     return 1;
+  }
+  if (haystack.startsWith(needle)) {
+    return 3;
+  }
+  if (haystack.includes(needle)) {
+    return 2;
+  }
+  let from = 0;
+  for (const character of needle) {
+    from = haystack.indexOf(character, from) + 1;
+    if (from === 0) {
+      return 0;
+    }
+  }
+  return 1;
 }
 /* The entries that match, best first within each group; without a query, in the order of the file. */
 export function filterEntries(entries, query) {
-    const trimmed = query.trim();
-    const scored = entries.map((entry, index) => ({ entry, index, score: scoreOf(entry.name, trimmed) })).filter((candidate) => candidate.score > 0);
-    return scored
-        .sort((left, right) => (trimmed === '' ? left.index - right.index : right.score - left.score || left.index - right.index))
-        .map((candidate) => candidate.entry);
+  const trimmed = query.trim();
+  const scored = entries.map((entry, index) => ({
+    entry,
+    index,
+    score: scoreOf(entry.name, trimmed)
+  })).filter(candidate => candidate.score > 0);
+  return scored.sort((left, right) => trimmed === '' ? left.index - right.index : right.score - left.score || left.index - right.index).map(candidate => candidate.entry);
 }
 /* The entries in their groups, in the order of the groups, and so in the order the list is walked with the arrows. */
 export function groupEntries(entries) {
-    return SYMBOL_GROUPS.flatMap((group) => {
-        const own = entries.filter((entry) => groupOfKind(entry.kind) === group);
-        return own.length === 0 ? [] : [{ group, entries: own }];
-    });
+  return SYMBOL_GROUPS.flatMap(group => {
+    const own = entries.filter(entry => groupOfKind(entry.kind) === group);
+    return own.length === 0 ? [] : [{
+      group,
+      entries: own
+    }];
+  });
 }
 /* `#name` searches the whole project, `:12` goes to a line, anything else filters the symbols of the file. */
 export function modeOf(input) {
-    if (input.startsWith('#')) {
-        return { mode: 'workspace', text: input.slice(1).trim() };
-    }
-    if (input.startsWith(':')) {
-        const line = Number.parseInt(input.slice(1), 10);
-        return { mode: 'line', line: Number.isFinite(line) && line > 0 ? line : null };
-    }
-    return { mode: 'symbol', text: input };
+  if (input.startsWith('#')) {
+    return {
+      mode: 'workspace',
+      text: input.slice(1).trim()
+    };
+  }
+  if (input.startsWith(':')) {
+    const line = Number.parseInt(input.slice(1), 10);
+    return {
+      mode: 'line',
+      line: Number.isFinite(line) && line > 0 ? line : null
+    };
+  }
+  return {
+    mode: 'symbol',
+    text: input
+  };
 }
 export function workspaceEntriesOf(result) {
-    return (result ?? []).map((symbol, index) => ({
-        id: String(index),
-        name: symbol.name,
-        kind: symbol.kind,
-        container: symbol.containerName ?? '',
-        uri: symbol.location.uri,
-        line: 'range' in symbol.location ? symbol.location.range.start.line : 0
-    }));
-}
+  return (result ?? []).map((symbol, index) => ({
+    id: String(index),
+    name: symbol.name,
+    kind: symbol.kind,
+    container: symbol.containerName ?? '',
+    uri: symbol.location.uri,
+    line: 'range' in symbol.location ? symbol.location.range.start.line : 0
+  }));
+}