@opensumi/ide-utils 2.21.13 → 2.22.0

package/src/buffer.ts

@@ -0,0 +1,290 @@
+/* ---------------------------------------------------------------------------------------------
+ *  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/arrays.ts
+import { toCanonicalName, iconvDecode, UTF8 } from './encoding';
+import * as strings from './strings';
+
+let textEncoder: TextEncoder | null;
+
+const hasBuffer = typeof Buffer !== 'undefined';
+const hasTextEncoder = typeof TextEncoder !== 'undefined';
+const hasTextDecoder = typeof TextDecoder !== 'undefined';
+
+export class BinaryBuffer {
+  static alloc(byteLength: number): BinaryBuffer {
+    if (hasBuffer) {
+      return new BinaryBuffer(Buffer.allocUnsafe(byteLength));
+    } else {
+      return new BinaryBuffer(new Uint8Array(byteLength));
+    }
+  }
+
+  static wrap(actual: Uint8Array): BinaryBuffer {
+    if (hasBuffer && !Buffer.isBuffer(actual)) {
+      // https://nodejs.org/dist/latest-v10.x/docs/api/buffer.html#buffer_class_method_buffer_from_arraybuffer_byteoffset_length
+      // Create a zero-copy Buffer wrapper around the ArrayBuffer pointed to by the Uint8Array
+      actual = Buffer.from(actual.buffer, actual.byteOffset, actual.byteLength);
+    }
+    return new BinaryBuffer(actual);
+  }
+
+  /**
+   * fromString 产生的 BinaryBuffer 的 encoding 都是 utf8
+   * @param source source string
+   */
+  static fromString(source: string): BinaryBuffer {
+    if (hasBuffer) {
+      return new BinaryBuffer(Buffer.from(source));
+    } else if (hasTextEncoder) {
+      if (!textEncoder) {
+        textEncoder = new TextEncoder();
+      }
+      return new BinaryBuffer(textEncoder.encode(source));
+    } else {
+      return new BinaryBuffer(strings.encodeUTF8(source));
+    }
+  }
+
+  static concat(buffers: BinaryBuffer[], totalLength?: number): BinaryBuffer {
+    if (typeof totalLength === 'undefined') {
+      totalLength = 0;
+      for (let i = 0, len = buffers.length; i < len; i++) {
+        totalLength += buffers[i].byteLength;
+      }
+    }
+
+    const ret = BinaryBuffer.alloc(totalLength);
+    let offset = 0;
+    for (let i = 0, len = buffers.length; i < len; i++) {
+      const element = buffers[i];
+      ret.set(element, offset);
+      offset += element.byteLength;
+    }
+
+    return ret;
+  }
+
+  readonly buffer: Uint8Array;
+  readonly byteLength: number;
+
+  private constructor(buffer: Uint8Array) {
+    this.buffer = buffer;
+    this.byteLength = this.buffer.byteLength;
+  }
+
+  /**
+   * 将 BinaryBuffer 转为字符串
+   * @param encoding 字节编码，不传默认为 utf8。需要传入 `SUPPORTED_ENCODINGS` 已有的键值。
+   */
+  toString(encoding?: string): string {
+    if (hasBuffer) {
+      // 可能原生 toString 比 iconv.decode 要快
+      if (encoding === undefined || encoding === 'utf8') {
+        return (this.buffer as Buffer).toString();
+      }
+      return iconvDecode(this.buffer as Buffer, encoding);
+    } else if (hasTextDecoder) {
+      encoding = toCanonicalName(encoding || UTF8);
+      return new TextDecoder(encoding).decode(this.buffer);
+    } else {
+      return strings.decodeUTF8(this.buffer);
+    }
+  }
+
+  slice(start?: number, end?: number): BinaryBuffer {
+    // IMPORTANT: use subarray instead of slice because TypedArray#slice
+    // creates shallow copy and NodeBuffer#slice doesn't. The use of subarray
+    // ensures the same, performant, behaviour.
+    return new BinaryBuffer(this.buffer.subarray(start! /* bad lib.d.ts*/, end));
+  }
+
+  set(array: BinaryBuffer | Uint8Array, offset?: number): void {
+    if (array instanceof BinaryBuffer) {
+      this.buffer.set(array.buffer, offset);
+    } else {
+      this.buffer.set(array, offset);
+    }
+  }
+
+  readUInt32BE(offset: number): number {
+    return readUInt32BE(this.buffer, offset);
+  }
+
+  writeUInt32BE(value: number, offset: number): void {
+    writeUInt32BE(this.buffer, value, offset);
+  }
+
+  readUInt32LE(offset: number): number {
+    return readUInt32LE(this.buffer, offset);
+  }
+
+  writeUInt32LE(value: number, offset: number): void {
+    writeUInt32LE(this.buffer, value, offset);
+  }
+
+  readUInt8(offset: number): number {
+    return readUInt8(this.buffer, offset);
+  }
+
+  writeUInt8(value: number, offset: number): void {
+    writeUInt8(this.buffer, value, offset);
+  }
+}
+
+export function readUInt16LE(source: Uint8Array, offset: number): number {
+  return ((source[offset + 0] << 0) >>> 0) | ((source[offset + 1] << 8) >>> 0);
+}
+
+export function writeUInt16LE(destination: Uint8Array, value: number, offset: number): void {
+  destination[offset + 0] = value & 0b11111111;
+  value = value >>> 8;
+  destination[offset + 1] = value & 0b11111111;
+}
+
+export function readUInt32BE(source: Uint8Array, offset: number): number {
+  return source[offset] * 2 ** 24 + source[offset + 1] * 2 ** 16 + source[offset + 2] * 2 ** 8 + source[offset + 3];
+}
+
+export function writeUInt32BE(destination: Uint8Array, value: number, offset: number): void {
+  destination[offset + 3] = value;
+  value = value >>> 8;
+  destination[offset + 2] = value;
+  value = value >>> 8;
+  destination[offset + 1] = value;
+  value = value >>> 8;
+  destination[offset] = value;
+}
+
+export function readUInt32LE(source: Uint8Array, offset: number): number {
+  return (
+    ((source[offset + 0] << 0) >>> 0) |
+    ((source[offset + 1] << 8) >>> 0) |
+    ((source[offset + 2] << 16) >>> 0) |
+    ((source[offset + 3] << 24) >>> 0)
+  );
+}
+
+export function writeUInt32LE(destination: Uint8Array, value: number, offset: number): void {
+  destination[offset + 0] = value & 0b11111111;
+  value = value >>> 8;
+  destination[offset + 1] = value & 0b11111111;
+  value = value >>> 8;
+  destination[offset + 2] = value & 0b11111111;
+  value = value >>> 8;
+  destination[offset + 3] = value & 0b11111111;
+}
+
+export function readUInt8(source: Uint8Array, offset: number): number {
+  return source[offset];
+}
+
+export function writeUInt8(destination: Uint8Array, value: number, offset: number): void {
+  destination[offset] = value;
+}
+
+/** Decodes base64 to a uint8 array. URL-encoded and unpadded base64 is allowed. */
+export function decodeBase64(encoded: string) {
+  let building = 0;
+  let remainder = 0;
+  let bufi = 0;
+
+  // The simpler way to do this is `Uint8Array.from(atob(str), c => c.charCodeAt(0))`,
+  // but that's about 10-20x slower than this function in current Chromium versions.
+
+  const buffer = new Uint8Array(Math.floor((encoded.length / 4) * 3));
+  const append = (value: number) => {
+    switch (remainder) {
+      case 3:
+        buffer[bufi++] = building | value;
+        remainder = 0;
+        break;
+      case 2:
+        buffer[bufi++] = building | (value >>> 2);
+        building = value << 6;
+        remainder = 3;
+        break;
+      case 1:
+        buffer[bufi++] = building | (value >>> 4);
+        building = value << 4;
+        remainder = 2;
+        break;
+      default:
+        building = value << 2;
+        remainder = 1;
+    }
+  };
+
+  for (let i = 0; i < encoded.length; i++) {
+    const code = encoded.charCodeAt(i);
+    // See https://datatracker.ietf.org/doc/html/rfc4648#section-4
+    // This branchy code is about 3x faster than an indexOf on a base64 char string.
+    if (code >= 65 && code <= 90) {
+      append(code - 65); // A-Z starts ranges from char code 65 to 90
+    } else if (code >= 97 && code <= 122) {
+      append(code - 97 + 26); // a-z starts ranges from char code 97 to 122, starting at byte 26
+    } else if (code >= 48 && code <= 57) {
+      append(code - 48 + 52); // 0-9 starts ranges from char code 48 to 58, starting at byte 52
+    } else if (code === 43 || code === 45) {
+      append(62); // "+" or "-" for URLS
+    } else if (code === 47 || code === 95) {
+      append(63); // "/" or "_" for URLS
+    } else if (code === 61) {
+      break; // "="
+    } else {
+      throw new SyntaxError(`Unexpected base64 character ${encoded[i]}`);
+    }
+  }
+
+  const unpadded = bufi;
+  while (remainder > 0) {
+    append(0);
+  }
+
+  // slice is needed to account for overestimation due to padding
+  return BinaryBuffer.wrap(buffer).slice(0, unpadded);
+}
+
+const base64Alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const base64UrlSafeAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+
+/** Encodes a buffer to a base64 string. */
+export function encodeBase64({ buffer }: BinaryBuffer, padded = true, urlSafe = false) {
+  const dictionary = urlSafe ? base64UrlSafeAlphabet : base64Alphabet;
+  let output = '';
+
+  const remainder = buffer.byteLength % 3;
+
+  let i = 0;
+  for (; i < buffer.byteLength - remainder; i += 3) {
+    const a = buffer[i + 0];
+    const b = buffer[i + 1];
+    const c = buffer[i + 2];
+
+    output += dictionary[a >>> 2];
+    output += dictionary[((a << 4) | (b >>> 4)) & 0b111111];
+    output += dictionary[((b << 2) | (c >>> 6)) & 0b111111];
+    output += dictionary[c & 0b111111];
+  }
+
+  if (remainder === 1) {
+    const a = buffer[i + 0];
+    output += dictionary[a >>> 2];
+    output += dictionary[(a << 4) & 0b111111];
+    if (padded) {
+      output += '==';
+    }
+  } else if (remainder === 2) {
+    const a = buffer[i + 0];
+    const b = buffer[i + 1];
+    output += dictionary[a >>> 2];
+    output += dictionary[((a << 4) | (b >>> 4)) & 0b111111];
+    output += dictionary[(b << 2) & 0b111111];
+    if (padded) {
+      output += '=';
+    }
+  }
+
+  return output;
+}

package/src/cache.ts

@@ -0,0 +1,37 @@
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export class Cache<T> {
+  private static readonly enableDebugLogging = false;
+
+  private readonly _data = new Map<number, readonly T[]>();
+  private _idPool = 1;
+
+  constructor(private readonly id: string) {}
+
+  add(item: readonly T[]): number {
+    const id = this._idPool++;
+    this._data.set(id, item);
+    this.logDebugInfo();
+    return id;
+  }
+
+  get(pid: number, id: number): T | undefined {
+    return this._data.has(pid) ? this._data.get(pid)![id] : undefined;
+  }
+
+  delete(id: number) {
+    this._data.delete(id);
+    this.logDebugInfo();
+  }
+
+  private logDebugInfo() {
+    if (!Cache.enableDebugLogging) {
+      return;
+    }
+    // eslint-disable-next-line no-console
+    console.log(`${this.id} cache size — ${this._data.size}`);
+  }
+}

package/src/cancellation.ts

@@ -0,0 +1,136 @@
+/* ---------------------------------------------------------------------------------------------
+ *  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/cancellation.ts
+
+import { IDisposable } from './disposable';
+import { Emitter, Event } from './event';
+
+export interface CancellationToken {
+  readonly isCancellationRequested: boolean;
+  /**
+   * An event emitted when cancellation is requested
+   * @event
+   */
+  readonly onCancellationRequested: Event<any>;
+}
+
+const shortcutEvent = Object.freeze(function (callback, context?): IDisposable {
+  const handle = setTimeout(callback.bind(context), 0);
+  return {
+    dispose() {
+      clearTimeout(handle);
+    },
+  };
+} as Event<any>);
+
+export namespace CancellationToken {
+  export function isCancellationToken(thing: any): thing is CancellationToken {
+    if (thing === CancellationToken.None || thing === CancellationToken.Cancelled) {
+      return true;
+    }
+    if (thing instanceof MutableToken) {
+      return true;
+    }
+    if (!thing || typeof thing !== 'object') {
+      return false;
+    }
+    return (
+      typeof (thing as CancellationToken).isCancellationRequested === 'boolean' &&
+      typeof (thing as CancellationToken).onCancellationRequested === 'function'
+    );
+  }
+
+  export const None: CancellationToken = Object.freeze({
+    isCancellationRequested: false,
+    onCancellationRequested: Event.None,
+  });
+
+  export const Cancelled: CancellationToken = Object.freeze({
+    isCancellationRequested: true,
+    onCancellationRequested: shortcutEvent,
+  });
+}
+
+class MutableToken implements CancellationToken {
+  private _isCancelled = false;
+  private _emitter: Emitter<any> | null = null;
+
+  public cancel() {
+    if (!this._isCancelled) {
+      this._isCancelled = true;
+      if (this._emitter) {
+        this._emitter.fire(undefined);
+        this.dispose();
+      }
+    }
+  }
+
+  get isCancellationRequested(): boolean {
+    return this._isCancelled;
+  }
+
+  get onCancellationRequested(): Event<any> {
+    if (this._isCancelled) {
+      return shortcutEvent;
+    }
+    if (!this._emitter) {
+      this._emitter = new Emitter<any>();
+    }
+    return this._emitter.event;
+  }
+
+  public dispose(): void {
+    if (this._emitter) {
+      this._emitter.dispose();
+      this._emitter = null;
+    }
+  }
+}
+
+export class CancellationTokenSource {
+  private _token?: CancellationToken = undefined;
+  private _parentListener?: IDisposable = undefined;
+
+  constructor(parent?: CancellationToken) {
+    this._parentListener = parent && parent.onCancellationRequested(this.cancel, this);
+  }
+
+  get token(): CancellationToken {
+    if (!this._token) {
+      // be lazy and create the token only when
+      // actually needed
+      this._token = new MutableToken();
+    }
+    return this._token;
+  }
+
+  cancel(): void {
+    if (!this._token) {
+      // save an object by returning the default
+      // cancelled token when cancellation happens
+      // before someone asks for the token
+      this._token = CancellationToken.Cancelled;
+    } else if (this._token instanceof MutableToken) {
+      // actually cancel
+      this._token.cancel();
+    }
+  }
+
+  dispose(cancel = false): void {
+    if (cancel) {
+      this.cancel();
+    }
+    if (this._parentListener) {
+      this._parentListener.dispose();
+    }
+    if (!this._token) {
+      // ensure to initialize with an empty token if we had none
+      this._token = CancellationToken.None;
+    } else if (this._token instanceof MutableToken) {
+      // actually dispose
+      this._token.dispose();
+    }
+  }
+}