@opensumi/ide-core-common 2.21.13 → 2.22.0

package/src/hash-calculate/WASMInterface.ts

@@ -0,0 +1,266 @@
+/* ---------------------------------------------------------------------------------------------
+ * MIT License Copyright (c) 2020 Dani All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * https://github.com/Daninet/hash-wasm
+ *--------------------------------------------------------------------------------------------*/
+
+// copy and modified from https://github.com/Daninet/hash-wasm/blob/bd3a205ca5603fc80adf71d0966fc72e8d4fa0ef/lib/WASMInterface.ts
+
+import { Mutex } from './mutex';
+import { decodeBase64, getDigestHex, getUInt8Buffer, IDataType, writeHexToUInt8, hexStringEqualsUInt8 } from './util';
+
+export const MAX_HEAP = 16 * 1024;
+const WASM_FUNC_HASH_LENGTH = 4;
+const wasmMutex = new Mutex();
+
+type ThenArg<T> = T extends Promise<infer U> ? U : T extends (...args: any[]) => Promise<infer V> ? V : T;
+
+export interface IHasher {
+  /**
+   * Initializes hash state to default value
+   */
+  init: () => IHasher;
+  /**
+   * Updates the hash content with the given data
+   */
+  update: (data: IDataType) => IHasher;
+  /**
+   * Calculates the hash of all of the data passed to be hashed with hash.update().
+   * Defaults to hexadecimal string
+   * @param outputType If outputType is "binary", it returns Uint8Array. Otherwise it
+   *                   returns hexadecimal string
+   */
+  digest: {
+    (outputType: 'binary'): Uint8Array;
+    (outputType?: 'hex'): string;
+  };
+  /**
+   * Save the current internal state of the hasher for later resumption with load().
+   * Cannot be called before .init() or after .digest()
+   *
+   * Note that this state can include arbitrary information about the value being hashed (e.g.
+   * could include N plaintext bytes from the value), so needs to be treated as being as
+   * sensitive as the input value itself.
+   */
+  save: () => Uint8Array;
+  /**
+   * Resume a state that was created by save(). If this state was not created by a
+   * compatible build of hash-wasm, an exception will be thrown.
+   */
+  load: (state: Uint8Array) => IHasher;
+  /**
+   * Block size in bytes
+   */
+  blockSize: number;
+  /**
+   * Digest size in bytes
+   */
+  digestSize: number;
+}
+
+const wasmModuleCache = new Map<string, Promise<WebAssembly.Module>>();
+
+export async function WASMInterface(binary: any, hashLength: number) {
+  let wasmInstance: WebAssembly.Instance | null = null;
+  let memoryView: Uint8Array | null = null;
+  let initialized = false;
+
+  if (typeof WebAssembly === 'undefined') {
+    throw new Error('WebAssembly is not supported in this environment!');
+  }
+
+  const writeMemory = (data: Uint8Array, offset = 0) => {
+    memoryView?.set(data, offset);
+  };
+
+  const getMemory = () => memoryView;
+  const getExports = () => wasmInstance?.exports;
+
+  const setMemorySize = (totalSize: number) => {
+    (wasmInstance?.exports as any).Hash_SetMemorySize(totalSize);
+    const arrayOffset: number = (wasmInstance?.exports as any).Hash_GetBuffer();
+    const memoryBuffer = (wasmInstance?.exports as any).memory.buffer;
+    memoryView = new Uint8Array(memoryBuffer, arrayOffset, totalSize);
+  };
+
+  const getStateSize = () => {
+    const view = new DataView((wasmInstance?.exports as any).memory.buffer);
+    const stateSize = view.getUint32((wasmInstance?.exports as any).STATE_SIZE, true);
+    return stateSize;
+  };
+
+  const loadWASMPromise = wasmMutex.dispatch(async () => {
+    if (!wasmModuleCache.has(binary.name)) {
+      const asm = decodeBase64(binary.data);
+      const promise = WebAssembly.compile(asm);
+
+      wasmModuleCache.set(binary.name, promise);
+    }
+
+    const module = await wasmModuleCache.get(binary.name);
+    wasmInstance = await WebAssembly.instantiate(module!);
+  });
+
+  const setupInterface = async () => {
+    if (!wasmInstance) {
+      await loadWASMPromise;
+    }
+
+    const arrayOffset: number = (wasmInstance?.exports as any).Hash_GetBuffer();
+    const memoryBuffer = (wasmInstance?.exports as any).memory.buffer;
+    memoryView = new Uint8Array(memoryBuffer, arrayOffset, MAX_HEAP);
+  };
+
+  const init = (bits: number | null = null) => {
+    initialized = true;
+    (wasmInstance?.exports as any).Hash_Init(bits);
+  };
+
+  const updateUInt8Array = (data: Uint8Array): void => {
+    let read = 0;
+    while (read < data.length) {
+      const chunk = data.subarray(read, read + MAX_HEAP);
+      read += chunk.length;
+      memoryView?.set(chunk);
+      (wasmInstance?.exports as any).Hash_Update(chunk.length);
+    }
+  };
+
+  const update = (data: IDataType) => {
+    if (!initialized) {
+      throw new Error('update() called before init()');
+    }
+    const Uint8Buffer = getUInt8Buffer(data);
+    updateUInt8Array(Uint8Buffer);
+  };
+
+  const digestChars = new Uint8Array(hashLength * 2);
+
+  const digest = (outputType: 'hex' | 'binary', padding: number | null = null): Uint8Array | string => {
+    if (!initialized) {
+      throw new Error('digest() called before init()');
+    }
+    initialized = false;
+
+    (wasmInstance?.exports as any).Hash_Final(padding);
+
+    if (outputType === 'binary') {
+      // the data is copied to allow GC of the original memory object
+      return memoryView!.slice(0, hashLength);
+    }
+
+    return getDigestHex(digestChars, memoryView!, hashLength);
+  };
+
+  const save = (): Uint8Array => {
+    if (!initialized) {
+      throw new Error('save() can only be called after init() and before digest()');
+    }
+
+    const stateOffset: number = (wasmInstance?.exports as any).Hash_GetState();
+    const stateLength: number = getStateSize();
+    const memoryBuffer = (wasmInstance?.exports as any).memory.buffer;
+    const internalState = new Uint8Array(memoryBuffer, stateOffset, stateLength);
+
+    // prefix is 4 bytes from SHA1 hash of the WASM binary
+    // it is used to detect incompatible internal states between different versions of hash-wasm
+    const prefixedState = new Uint8Array(WASM_FUNC_HASH_LENGTH + stateLength);
+    writeHexToUInt8(prefixedState, binary.hash);
+    prefixedState.set(internalState, WASM_FUNC_HASH_LENGTH);
+    return prefixedState;
+  };
+
+  const load = (state: Uint8Array) => {
+    if (!(state instanceof Uint8Array)) {
+      throw new Error('load() expects an Uint8Array generated by save()');
+    }
+
+    const stateOffset: number = (wasmInstance?.exports as any).Hash_GetState();
+    const stateLength: number = getStateSize();
+    const overallLength: number = WASM_FUNC_HASH_LENGTH + stateLength;
+    const memoryBuffer = (wasmInstance?.exports as any).memory.buffer;
+
+    if (state.length !== overallLength) {
+      throw new Error(`Bad state length (expected ${overallLength} bytes, got ${state.length})`);
+    }
+
+    if (!hexStringEqualsUInt8(binary.hash, state.subarray(0, WASM_FUNC_HASH_LENGTH))) {
+      throw new Error('This state was written by an incompatible hash implementation');
+    }
+
+    const internalState = state.subarray(WASM_FUNC_HASH_LENGTH);
+    new Uint8Array(memoryBuffer, stateOffset, stateLength).set(internalState);
+    initialized = true;
+  };
+
+  const isDataShort = (data: IDataType) => {
+    if (typeof data === 'string') {
+      // worst case is 4 bytes / char
+      return data.length < MAX_HEAP / 4;
+    }
+
+    return data.byteLength < MAX_HEAP;
+  };
+
+  let canSimplify: (data: IDataType, initParam?: number) => boolean = isDataShort;
+
+  switch (binary.name) {
+    case 'argon2':
+    case 'scrypt':
+      canSimplify = () => true;
+      break;
+
+    case 'blake2b':
+    case 'blake2s':
+      // if there is a key at blake2 then cannot simplify
+      canSimplify = (data, initParam) => initParam! <= 512 && isDataShort(data);
+      break;
+
+    case 'blake3':
+      // if there is a key at blake3 then cannot simplify
+      canSimplify = (data, initParam) => initParam === 0 && isDataShort(data);
+      break;
+
+    case 'xxhash64': // cannot simplify
+    case 'xxhash3':
+    case 'xxhash128':
+      canSimplify = () => false;
+      break;
+
+    default:
+      break;
+  }
+
+  // shorthand for (init + update + digest) for better performance
+  const calculate = (data: IDataType, initParam = null, digestParam = null): string => {
+    if (!canSimplify(data, initParam!)) {
+      init(initParam);
+      update(data);
+      return digest('hex', digestParam) as string;
+    }
+
+    const buffer = getUInt8Buffer(data);
+    memoryView?.set(buffer);
+    (wasmInstance?.exports as any).Hash_Calculate(buffer.length, initParam, digestParam);
+
+    return getDigestHex(digestChars, memoryView!, hashLength);
+  };
+
+  await setupInterface();
+
+  return {
+    getMemory,
+    writeMemory,
+    getExports,
+    setMemorySize,
+    init,
+    update,
+    digest,
+    save,
+    load,
+    calculate,
+    hashLength,
+  };
+}
+
+export type IWASMInterface = ThenArg<ReturnType<typeof WASMInterface>>;

package/src/hash-calculate/hash-calculate.ts

@@ -0,0 +1,53 @@
+import { Injectable } from '@opensumi/di';
+import { memoize } from '@opensumi/ide-utils';
+
+import { lockedCreate } from './lockedCreate';
+import wasmJson from './md5.wasm.json';
+import { Mutex } from './mutex';
+import { IDataType } from './util';
+
+export const IHashCalculateService = Symbol('IHashCalculateService');
+
+export interface IHashCalculateService {
+  initialize(): Promise<void>;
+
+  calculate(content: IDataType): string;
+
+  readonly initialized: boolean;
+}
+
+type Awaited<T> = T extends PromiseLike<infer U> ? U : T;
+
+type Calculator = Awaited<ReturnType<typeof lockedCreate>>;
+
+function md5WasmCalculatorFactory() {
+  const mutex = new Mutex();
+  return lockedCreate(mutex, wasmJson, 16);
+}
+
+@Injectable()
+export class HashCalculateServiceImpl implements IHashCalculateService {
+  private cachedCalculator?: Calculator;
+
+  private _initialized = false;
+
+  public get initialized() {
+    return this._initialized;
+  }
+
+  @memoize
+  async initialize(): Promise<void> {
+    if (!this.cachedCalculator) {
+      this.cachedCalculator = await md5WasmCalculatorFactory();
+    }
+    this._initialized = true;
+  }
+
+  calculate(content: IDataType): string {
+    if (!this.initialized) {
+      throw new Error('Please call #initialize first!');
+    }
+    const hash = this.cachedCalculator!.calculate(content);
+    return hash;
+  }
+}

package/src/hash-calculate/lockedCreate.ts

@@ -0,0 +1,17 @@
+/* ---------------------------------------------------------------------------------------------
+ * MIT License Copyright (c) 2020 Dani All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * https://github.com/Daninet/hash-wasm
+ *--------------------------------------------------------------------------------------------*/
+
+// copy and modified from https://github.com/Daninet/hash-wasm/blob/bd3a205ca5603fc80adf71d0966fc72e8d4fa0ef/lib/lockedCreate.ts
+
+import { Mutex } from './mutex';
+import { WASMInterface, IWASMInterface } from './WASMInterface';
+
+export async function lockedCreate(mutex: Mutex, binary: any, hashLength: number): Promise<IWASMInterface> {
+  const unlock = await mutex.lock();
+  const wasm = await WASMInterface(binary, hashLength);
+  unlock();
+  return wasm;
+}

package/src/hash-calculate/md5.wasm.json

@@ -0,0 +1 @@
+{"name":"md5","data":"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","hash":"9b0fac7d"}

package/src/hash-calculate/mutex.ts

@@ -0,0 +1,30 @@
+/* ---------------------------------------------------------------------------------------------
+ * MIT License Copyright (c) 2020 Dani All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * https://github.com/Daninet/hash-wasm
+ *--------------------------------------------------------------------------------------------*/
+
+// copy and modified from https://github.com/Daninet/hash-wasm/blob/bd3a205ca5603fc80adf71d0966fc72e8d4fa0ef/lib/mutex.ts
+
+export class Mutex {
+  private mutex = Promise.resolve();
+
+  lock(): PromiseLike<() => void> {
+    let begin: (unlock: () => void) => void = () => {};
+
+    this.mutex = this.mutex.then(() => new Promise(begin));
+
+    return new Promise((res) => {
+      begin = res;
+    });
+  }
+
+  async dispatch<T>(fn: () => PromiseLike<T>): Promise<T> {
+    const unlock = await this.lock();
+    try {
+      return await Promise.resolve(fn());
+    } finally {
+      unlock();
+    }
+  }
+}

package/src/hash-calculate/util.ts

@@ -0,0 +1,190 @@
+/* ---------------------------------------------------------------------------------------------
+ * MIT License Copyright (c) 2020 Dani All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * https://github.com/Daninet/hash-wasm
+ *--------------------------------------------------------------------------------------------*/
+
+// copy and modified from https://github.com/Daninet/hash-wasm/blob/bd3a205ca5603fc80adf71d0966fc72e8d4fa0ef/lib/util.ts
+
+function getGlobal() {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  }
+  // eslint-disable-next-line no-restricted-globals
+  if (typeof self !== 'undefined') {
+    return self;
+  }
+  if (typeof window !== 'undefined') {
+    return window;
+  }
+  return global;
+}
+
+const globalObject = getGlobal();
+// @ts-ignore
+const nodeBuffer = globalObject.Buffer ?? null;
+// @ts-ignore
+const textEncoder = globalObject.TextEncoder ? new globalObject.TextEncoder() : null;
+
+export type ITypedArray = Uint8Array | Uint16Array | Uint32Array;
+export type IDataType = string | Buffer | ITypedArray;
+
+export function intArrayToString(arr: Uint8Array, len: number): string {
+  return String.fromCharCode(...arr.subarray(0, len));
+}
+
+function hexCharCodesToInt(a: number, b: number): number {
+  return (((a & 0xf) + ((a >> 6) | ((a >> 3) & 0x8))) << 4) | ((b & 0xf) + ((b >> 6) | ((b >> 3) & 0x8)));
+}
+
+export function writeHexToUInt8(buf: Uint8Array, str: string) {
+  const size = str.length >> 1;
+  for (let i = 0; i < size; i++) {
+    const index = i << 1;
+    buf[i] = hexCharCodesToInt(str.charCodeAt(index), str.charCodeAt(index + 1));
+  }
+}
+
+export function hexStringEqualsUInt8(str: string, buf: Uint8Array): boolean {
+  if (str.length !== buf.length * 2) {
+    return false;
+  }
+  for (let i = 0; i < buf.length; i++) {
+    const strIndex = i << 1;
+    if (buf[i] !== hexCharCodesToInt(str.charCodeAt(strIndex), str.charCodeAt(strIndex + 1))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+const alpha = 'a'.charCodeAt(0) - 10;
+const digit = '0'.charCodeAt(0);
+export function getDigestHex(tmpBuffer: Uint8Array, input: Uint8Array, hashLength: number): string {
+  let p = 0;
+  /* eslint-disable no-plusplus */
+  for (let i = 0; i < hashLength; i++) {
+    let nibble = input[i] >>> 4;
+    tmpBuffer[p++] = nibble > 9 ? nibble + alpha : nibble + digit;
+    nibble = input[i] & 0xf;
+    tmpBuffer[p++] = nibble > 9 ? nibble + alpha : nibble + digit;
+  }
+  /* eslint-enable no-plusplus */
+
+  return String.fromCharCode.apply(null, tmpBuffer as unknown as number[]);
+}
+
+export const getUInt8Buffer =
+  nodeBuffer !== null
+    ? (data: IDataType): Uint8Array => {
+        if (typeof data === 'string') {
+          const buf = nodeBuffer.from(data, 'utf8');
+          return new Uint8Array(buf.buffer, buf.byteOffset, buf.length);
+        }
+
+        if (nodeBuffer.isBuffer(data)) {
+          return new Uint8Array(data.buffer, data.byteOffset, data.length);
+        }
+
+        if (ArrayBuffer.isView(data)) {
+          return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+
+        throw new Error('Invalid data type!');
+      }
+    : (data: IDataType): Uint8Array => {
+        if (typeof data === 'string') {
+          return textEncoder.encode(data);
+        }
+
+        if (ArrayBuffer.isView(data)) {
+          return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+
+        throw new Error('Invalid data type!');
+      };
+
+const base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const base64Lookup = new Uint8Array(256);
+for (let i = 0; i < base64Chars.length; i++) {
+  base64Lookup[base64Chars.charCodeAt(i)] = i;
+}
+
+export function encodeBase64(data: Uint8Array, pad = true): string {
+  const len = data.length;
+  const extraBytes = len % 3;
+  const parts: string[] = [];
+
+  const len2 = len - extraBytes;
+  for (let i = 0; i < len2; i += 3) {
+    const tmp = ((data[i] << 16) & 0xff0000) + ((data[i + 1] << 8) & 0xff00) + (data[i + 2] & 0xff);
+
+    const triplet =
+      base64Chars.charAt((tmp >> 18) & 0x3f) +
+      base64Chars.charAt((tmp >> 12) & 0x3f) +
+      base64Chars.charAt((tmp >> 6) & 0x3f) +
+      base64Chars.charAt(tmp & 0x3f);
+
+    parts.push(triplet);
+  }
+
+  if (extraBytes === 1) {
+    const tmp = data[len - 1];
+    const a = base64Chars.charAt(tmp >> 2);
+    const b = base64Chars.charAt((tmp << 4) & 0x3f);
+
+    parts.push(`${a}${b}`);
+    if (pad) {
+      parts.push('==');
+    }
+  } else if (extraBytes === 2) {
+    const tmp = (data[len - 2] << 8) + data[len - 1];
+    const a = base64Chars.charAt(tmp >> 10);
+    const b = base64Chars.charAt((tmp >> 4) & 0x3f);
+    const c = base64Chars.charAt((tmp << 2) & 0x3f);
+    parts.push(`${a}${b}${c}`);
+    if (pad) {
+      parts.push('=');
+    }
+  }
+
+  return parts.join('');
+}
+
+export function getDecodeBase64Length(data: string): number {
+  let bufferLength = Math.floor(data.length * 0.75);
+  const len = data.length;
+
+  if (data[len - 1] === '=') {
+    bufferLength -= 1;
+    if (data[len - 2] === '=') {
+      bufferLength -= 1;
+    }
+  }
+
+  return bufferLength;
+}
+
+export function decodeBase64(data: string): Uint8Array {
+  const bufferLength = getDecodeBase64Length(data);
+  const len = data.length;
+
+  const bytes = new Uint8Array(bufferLength);
+
+  let p = 0;
+  for (let i = 0; i < len; i += 4) {
+    const encoded1 = base64Lookup[data.charCodeAt(i)];
+    const encoded2 = base64Lookup[data.charCodeAt(i + 1)];
+    const encoded3 = base64Lookup[data.charCodeAt(i + 2)];
+    const encoded4 = base64Lookup[data.charCodeAt(i + 3)];
+
+    bytes[p] = (encoded1 << 2) | (encoded2 >> 4);
+    p += 1;
+    bytes[p] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
+    p += 1;
+    bytes[p] = ((encoded3 & 3) << 6) | (encoded4 & 63);
+    p += 1;
+  }
+
+  return bytes;
+}

package/src/id-generator.ts

@@ -0,0 +1,15 @@
+export class IdGenerator {
+  private _prefix: string;
+  private _lastId: number;
+
+  constructor(prefix: string) {
+    this._prefix = prefix;
+    this._lastId = 0;
+  }
+
+  public nextId(): string {
+    return this._prefix + ++this._lastId;
+  }
+}
+
+export const defaultGenerator = new IdGenerator('id#');

package/src/index.ts

@@ -0,0 +1,39 @@
+export * from './di-helper';
+export * from './event-bus';
+export * from './contribution-provider';
+export * from './declare';
+export * from './editor';
+export * from './reference';
+export * from './module';
+export * from './command';
+export * from './menu';
+export * from './localize';
+export * from './types';
+export * from './application-props';
+export * from './application-error';
+export * from './preferences';
+export * from './storage';
+export * from './network';
+export * from './log';
+export * from './json-schema';
+export * from './reporter';
+export * from './connection';
+export * from './comparers';
+export * from './range';
+export * from './problem-pattern';
+export * from './problem-matcher';
+export * from './task-definition';
+export * from './node/port';
+export * from './line-text';
+export * from './keyboard';
+export * from './theme';
+export * from './env';
+export * from './credential';
+export * from './crypto';
+export * from './markdown';
+export * from './settings';
+export * from './utils';
+export * from './clipboard';
+export * from './mime';
+export * from './application.lifecycle';
+export * from './extension.schema';