@opensumi/ide-utils 2.21.13 → 2.22.0

package/src/linked-list.ts

@@ -0,0 +1,144 @@
+import { Iterator, IteratorResult, FIN } from './iterator';
+
+class Node<E> {
+  static readonly Undefined = new Node<any>(undefined);
+
+  element: E;
+  next: Node<E>;
+  prev: Node<E>;
+
+  constructor(element: E) {
+    this.element = element;
+    this.next = Node.Undefined;
+    this.prev = Node.Undefined;
+  }
+}
+
+export class LinkedList<E> {
+  private _first: Node<E> = Node.Undefined;
+  private _last: Node<E> = Node.Undefined;
+  private _size = 0;
+
+  get size(): number {
+    return this._size;
+  }
+
+  isEmpty(): boolean {
+    return this._first === Node.Undefined;
+  }
+
+  clear(): void {
+    this._first = Node.Undefined;
+    this._last = Node.Undefined;
+    this._size = 0;
+  }
+
+  unshift(element: E): () => void {
+    return this._insert(element, false);
+  }
+
+  push(element: E): () => void {
+    return this._insert(element, true);
+  }
+
+  private _insert(element: E, atTheEnd: boolean): () => void {
+    const newNode = new Node(element);
+    if (this._first === Node.Undefined) {
+      this._first = newNode;
+      this._last = newNode;
+    } else if (atTheEnd) {
+      // push
+      const oldLast = this._last!;
+      this._last = newNode;
+      newNode.prev = oldLast;
+      oldLast.next = newNode;
+    } else {
+      // unshift
+      const oldFirst = this._first;
+      this._first = newNode;
+      newNode.next = oldFirst;
+      oldFirst.prev = newNode;
+    }
+    this._size += 1;
+
+    let didRemove = false;
+    return () => {
+      if (!didRemove) {
+        didRemove = true;
+        this._remove(newNode);
+      }
+    };
+  }
+
+  shift(): E | undefined {
+    if (this._first === Node.Undefined) {
+      return undefined;
+    } else {
+      const res = this._first.element;
+      this._remove(this._first);
+      return res;
+    }
+  }
+
+  pop(): E | undefined {
+    if (this._last === Node.Undefined) {
+      return undefined;
+    } else {
+      const res = this._last.element;
+      this._remove(this._last);
+      return res;
+    }
+  }
+
+  private _remove(node: Node<E>): void {
+    if (node.prev !== Node.Undefined && node.next !== Node.Undefined) {
+      // middle
+      const anchor = node.prev;
+      anchor.next = node.next;
+      node.next.prev = anchor;
+    } else if (node.prev === Node.Undefined && node.next === Node.Undefined) {
+      // only node
+      this._first = Node.Undefined;
+      this._last = Node.Undefined;
+    } else if (node.next === Node.Undefined) {
+      // last
+      this._last = this._last!.prev!;
+      this._last.next = Node.Undefined;
+    } else if (node.prev === Node.Undefined) {
+      // first
+      this._first = this._first!.next!;
+      this._first.prev = Node.Undefined;
+    }
+
+    // done
+    this._size -= 1;
+  }
+
+  iterator(): Iterator<E> {
+    let element: { done: false; value: E };
+    let node = this._first;
+    return {
+      next(): IteratorResult<E> {
+        if (node === Node.Undefined) {
+          return FIN;
+        }
+
+        if (!element) {
+          element = { done: false, value: node.element };
+        } else {
+          element.value = node.element;
+        }
+        node = node.next;
+        return element;
+      },
+    };
+  }
+
+  toArray(): E[] {
+    const result: E[] = [];
+    for (let node = this._first; node !== Node.Undefined; node = node.next) {
+      result.push(node.element);
+    }
+    return result;
+  }
+}

package/src/linked-text.ts

@@ -0,0 +1,55 @@
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// Some code copied and modified from https://github.com/microsoft/vscode/blob/1.44.0/src/vs/base/common/linkedText.ts
+
+import { memoize } from './decorators';
+
+export interface ILink {
+  readonly label: string;
+  readonly href: string;
+  readonly title?: string;
+}
+
+export type LinkedTextNode = string | ILink;
+
+export class LinkedText {
+  constructor(readonly nodes: LinkedTextNode[]) {}
+
+  @memoize
+  toString(): string {
+    return this.nodes.map((node) => (typeof node === 'string' ? node : node.label)).join('');
+  }
+}
+
+const LINK_REGEX = /\[([^\]]+)\]\(((?:https?:\/\/|command:)[^\)\s]+)(?: ("|')([^\3]+)(\3))?\)/gi;
+
+export function parseLinkedText(text: string): LinkedText {
+  const result: LinkedTextNode[] = [];
+
+  let index = 0;
+  let match: RegExpExecArray | null;
+
+  while ((match = LINK_REGEX.exec(text))) {
+    if (match.index - index > 0) {
+      result.push(text.substring(index, match.index));
+    }
+
+    const [, label, href, , title] = match;
+
+    if (title) {
+      result.push({ label, href, title });
+    } else {
+      result.push({ label, href });
+    }
+
+    index = match.index + match[0].length;
+  }
+
+  if (index < text.length) {
+    result.push(text.substring(index));
+  }
+
+  return new LinkedText(result);
+}

package/src/lru-map.ts

@@ -0,0 +1,133 @@
+import { Emitter, Event } from './event';
+
+export interface ILRULinkListNode<K> {
+  key: K | undefined;
+  next: ILRULinkListNode<K> | undefined;
+  prev: ILRULinkListNode<K> | undefined;
+}
+
+/**
+ * 自带LRU清理的Map
+ * 双向链表 + Map
+ */
+export class LRUMap<K, V> extends Map<K, V> {
+  private _onDidDelete = new Emitter<{ key: K; value: V }>();
+
+  public readonly onDidDelete: Event<{ key: K; value: V }> = this._onDidDelete.event;
+
+  private head: ILRULinkListNode<K> = { key: undefined, prev: undefined, next: undefined };
+
+  private tail: ILRULinkListNode<K> = { key: undefined, prev: undefined, next: undefined };
+
+  private map: Map<K, ILRULinkListNode<K>> = new Map();
+
+  constructor(private hardLimit: number, private softLimit: number) {
+    super();
+    if (hardLimit <= softLimit) {
+      throw new Error('hardLimit 必须比 softLimit大');
+    }
+    this.head.next = this.tail;
+    this.tail.prev = this.head;
+  }
+
+  private markRecentUsed(key: K) {
+    if (!this.map.get(key)) {
+      this.map.set(key, { key, prev: undefined, next: undefined });
+    }
+    this.putHead(this.map.get(key)!);
+  }
+
+  get(key: K): V | undefined {
+    const v = super.get(key);
+    if (v) {
+      this.markRecentUsed(key);
+    }
+    return v;
+  }
+
+  set(key: K, value: V): this {
+    this.markRecentUsed(key);
+    super.set(key, value);
+    if (this.size > this.hardLimit) {
+      this.shrink();
+    }
+    return this;
+  }
+
+  putHead(node: ILRULinkListNode<K>) {
+    this.deleteNodeFromList(node);
+    const lastHead = this.head.next;
+    this.head.next = node;
+    node.next = lastHead;
+    node.prev = undefined;
+    if (lastHead) {
+      lastHead.prev = node;
+    }
+  }
+
+  protected deleteNodeFromList(node: ILRULinkListNode<K>) {
+    if (node.prev) {
+      node.prev.next = node.next;
+    }
+    if (node.next) {
+      node.next.prev = node.prev;
+    }
+  }
+
+  delete(key: K) {
+    const node = this.map.get(key);
+    if (node) {
+      this.deleteNodeFromList(node);
+    }
+    const value = super.get(key);
+    this._onDidDelete.fire({
+      key,
+      value: value!,
+    });
+    return super.delete(key);
+  }
+
+  shrink() {
+    const toDelete = this.size - this.softLimit;
+    let toDeleteNode: ILRULinkListNode<K> = this.tail;
+    for (let i = 0; i < toDelete; i++) {
+      toDeleteNode = this.tail.prev!;
+      if (!toDeleteNode || toDeleteNode === this.head) {
+        break;
+      } else {
+        this.delete(toDeleteNode.key!);
+      }
+    }
+  }
+}
+
+const NOW = Symbol('now');
+/**
+ * 支持过期时间
+ */
+export class StaleLRUMap<K, V> extends LRUMap<K, V> {
+  constructor(hardLimit: number, softLimit: number, private maxAge: number) {
+    super(hardLimit, softLimit);
+  }
+
+  get(key: K): V | undefined {
+    const v = super.get(key);
+    if (v) {
+      if (!this._isStale(v)) {
+        return v;
+      }
+      // 过期则删除该条记录
+      this.delete(key);
+    }
+    return undefined;
+  }
+
+  set(key: K, value: V): this {
+    value[NOW] = Date.now();
+    return super.set(key, value);
+  }
+
+  private _isStale(value: V): boolean {
+    return value[NOW] + this.maxAge <= Date.now();
+  }
+}