@opensumi/ide-utils 2.21.13 → 2.22.0

package/src/const/encoding.ts

@@ -0,0 +1,242 @@
+export const SUPPORTED_ENCODINGS: {
+  [encoding: string]: { labelLong: string; labelShort: string; order: number; encodeOnly?: boolean; alias?: string };
+} = {
+  utf8: {
+    labelLong: 'UTF-8',
+    labelShort: 'UTF-8',
+    order: 1,
+    alias: 'utf8bom',
+  },
+  utf8bom: {
+    labelLong: 'UTF-8 with BOM',
+    labelShort: 'UTF-8 with BOM',
+    encodeOnly: true,
+    order: 2,
+    alias: 'utf8',
+  },
+  utf16le: {
+    labelLong: 'UTF-16 LE',
+    labelShort: 'UTF-16 LE',
+    order: 3,
+  },
+  utf16be: {
+    labelLong: 'UTF-16 BE',
+    labelShort: 'UTF-16 BE',
+    order: 4,
+  },
+  windows1252: {
+    labelLong: 'Western (Windows 1252)',
+    labelShort: 'Windows 1252',
+    order: 5,
+  },
+  iso88591: {
+    labelLong: 'Western (ISO 8859-1)',
+    labelShort: 'ISO 8859-1',
+    order: 6,
+  },
+  iso88593: {
+    labelLong: 'Western (ISO 8859-3)',
+    labelShort: 'ISO 8859-3',
+    order: 7,
+  },
+  iso885915: {
+    labelLong: 'Western (ISO 8859-15)',
+    labelShort: 'ISO 8859-15',
+    order: 8,
+  },
+  macroman: {
+    labelLong: 'Western (Mac Roman)',
+    labelShort: 'Mac Roman',
+    order: 9,
+  },
+  cp437: {
+    labelLong: 'DOS (CP 437)',
+    labelShort: 'CP437',
+    order: 10,
+  },
+  windows1256: {
+    labelLong: 'Arabic (Windows 1256)',
+    labelShort: 'Windows 1256',
+    order: 11,
+  },
+  iso88596: {
+    labelLong: 'Arabic (ISO 8859-6)',
+    labelShort: 'ISO 8859-6',
+    order: 12,
+  },
+  windows1257: {
+    labelLong: 'Baltic (Windows 1257)',
+    labelShort: 'Windows 1257',
+    order: 13,
+  },
+  iso88594: {
+    labelLong: 'Baltic (ISO 8859-4)',
+    labelShort: 'ISO 8859-4',
+    order: 14,
+  },
+  iso885914: {
+    labelLong: 'Celtic (ISO 8859-14)',
+    labelShort: 'ISO 8859-14',
+    order: 15,
+  },
+  windows1250: {
+    labelLong: 'Central European (Windows 1250)',
+    labelShort: 'Windows 1250',
+    order: 16,
+  },
+  iso88592: {
+    labelLong: 'Central European (ISO 8859-2)',
+    labelShort: 'ISO 8859-2',
+    order: 17,
+  },
+  cp852: {
+    labelLong: 'Central European (CP 852)',
+    labelShort: 'CP 852',
+    order: 18,
+  },
+  windows1251: {
+    labelLong: 'Cyrillic (Windows 1251)',
+    labelShort: 'Windows 1251',
+    order: 19,
+  },
+  cp866: {
+    labelLong: 'Cyrillic (CP 866)',
+    labelShort: 'CP 866',
+    order: 20,
+  },
+  iso88595: {
+    labelLong: 'Cyrillic (ISO 8859-5)',
+    labelShort: 'ISO 8859-5',
+    order: 21,
+  },
+  koi8r: {
+    labelLong: 'Cyrillic (KOI8-R)',
+    labelShort: 'KOI8-R',
+    order: 22,
+  },
+  koi8u: {
+    labelLong: 'Cyrillic (KOI8-U)',
+    labelShort: 'KOI8-U',
+    order: 23,
+  },
+  iso885913: {
+    labelLong: 'Estonian (ISO 8859-13)',
+    labelShort: 'ISO 8859-13',
+    order: 24,
+  },
+  windows1253: {
+    labelLong: 'Greek (Windows 1253)',
+    labelShort: 'Windows 1253',
+    order: 25,
+  },
+  iso88597: {
+    labelLong: 'Greek (ISO 8859-7)',
+    labelShort: 'ISO 8859-7',
+    order: 26,
+  },
+  windows1255: {
+    labelLong: 'Hebrew (Windows 1255)',
+    labelShort: 'Windows 1255',
+    order: 27,
+  },
+  iso88598: {
+    labelLong: 'Hebrew (ISO 8859-8)',
+    labelShort: 'ISO 8859-8',
+    order: 28,
+  },
+  iso885910: {
+    labelLong: 'Nordic (ISO 8859-10)',
+    labelShort: 'ISO 8859-10',
+    order: 29,
+  },
+  iso885916: {
+    labelLong: 'Romanian (ISO 8859-16)',
+    labelShort: 'ISO 8859-16',
+    order: 30,
+  },
+  windows1254: {
+    labelLong: 'Turkish (Windows 1254)',
+    labelShort: 'Windows 1254',
+    order: 31,
+  },
+  iso88599: {
+    labelLong: 'Turkish (ISO 8859-9)',
+    labelShort: 'ISO 8859-9',
+    order: 32,
+  },
+  windows1258: {
+    labelLong: 'Vietnamese (Windows 1258)',
+    labelShort: 'Windows 1258',
+    order: 33,
+  },
+  gbk: {
+    labelLong: 'Simplified Chinese (GBK)',
+    labelShort: 'GBK',
+    order: 34,
+  },
+  gb18030: {
+    labelLong: 'Simplified Chinese (GB18030)',
+    labelShort: 'GB18030',
+    order: 35,
+  },
+  cp950: {
+    labelLong: 'Traditional Chinese (Big5)',
+    labelShort: 'Big5',
+    order: 36,
+  },
+  big5hkscs: {
+    labelLong: 'Traditional Chinese (Big5-HKSCS)',
+    labelShort: 'Big5-HKSCS',
+    order: 37,
+  },
+  shiftjis: {
+    labelLong: 'Japanese (Shift JIS)',
+    labelShort: 'Shift JIS',
+    order: 38,
+  },
+  eucjp: {
+    labelLong: 'Japanese (EUC-JP)',
+    labelShort: 'EUC-JP',
+    order: 39,
+  },
+  euckr: {
+    labelLong: 'Korean (EUC-KR)',
+    labelShort: 'EUC-KR',
+    order: 40,
+  },
+  windows874: {
+    labelLong: 'Thai (Windows 874)',
+    labelShort: 'Windows 874',
+    order: 41,
+  },
+  iso885911: {
+    labelLong: 'Latin/Thai (ISO 8859-11)',
+    labelShort: 'ISO 8859-11',
+    order: 42,
+  },
+  koi8ru: {
+    labelLong: 'Cyrillic (KOI8-RU)',
+    labelShort: 'KOI8-RU',
+    order: 43,
+  },
+  koi8t: {
+    labelLong: 'Tajik (KOI8-T)',
+    labelShort: 'KOI8-T',
+    order: 44,
+  },
+  gb2312: {
+    labelLong: 'Simplified Chinese (GB 2312)',
+    labelShort: 'GB 2312',
+    order: 45,
+  },
+  cp865: {
+    labelLong: 'Nordic DOS (CP 865)',
+    labelShort: 'CP 865',
+    order: 46,
+  },
+  cp850: {
+    labelLong: 'Western European DOS (CP 850)',
+    labelShort: 'CP 850',
+    order: 47,
+  },
+};

package/src/const/index.ts

@@ -0,0 +1 @@
+export * from './encoding';

package/src/date.ts

@@ -0,0 +1,36 @@
+import { pad } from './strings';
+
+export function toLocalString(date: Date): string {
+  return (
+    date.getFullYear() +
+    '-' +
+    pad(date.getMonth() + 1, 2) +
+    '-' +
+    pad(date.getDate(), 2) +
+    ' ' +
+    pad(date.getHours(), 2) +
+    ':' +
+    pad(date.getMinutes(), 2) +
+    ':' +
+    pad(date.getSeconds(), 2)
+  );
+}
+
+export function toLocalISOString(date: Date): string {
+  return (
+    date.getFullYear() +
+    '-' +
+    pad(date.getMonth() + 1, 2) +
+    '-' +
+    pad(date.getDate(), 2) +
+    'T' +
+    pad(date.getHours(), 2) +
+    ':' +
+    pad(date.getMinutes(), 2) +
+    ':' +
+    pad(date.getSeconds(), 2) +
+    '.' +
+    (date.getMilliseconds() / 1000).toFixed(3).slice(2, 5) +
+    'Z'
+  );
+}

package/src/decorators.ts

@@ -0,0 +1,166 @@
+/* ---------------------------------------------------------------------------------------------
+ *  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/decorators.ts
+
+export function createDecorator(mapFn: (fn: Function, key: string) => Function): Function {
+  return (target: any, key: string, descriptor: any) => {
+    let fnKey: string | null = null;
+    let fn: Function | null = null;
+
+    if (typeof descriptor.value === 'function') {
+      fnKey = 'value';
+      fn = descriptor.value;
+    } else if (typeof descriptor.get === 'function') {
+      fnKey = 'get';
+      fn = descriptor.get;
+    }
+
+    if (!fn) {
+      throw new Error('not supported');
+    }
+
+    descriptor[fnKey!] = mapFn(fn, key);
+  };
+}
+
+let memoizeId = 0;
+export function createMemoizer() {
+  const memoizeKeyPrefix = `$memoize${memoizeId++}`;
+  let self: any;
+
+  const result = function memoize(target: any, key: string, descriptor: any) {
+    let fnKey: string | null = null;
+    let fn: Function | null = null;
+
+    if (typeof descriptor.value === 'function') {
+      fnKey = 'value';
+      fn = descriptor.value;
+
+      if (fn!.length !== 0) {
+        // eslint-disable-next-line no-console
+        console.warn('Memoize should only be used in functions with zero parameters');
+      }
+    } else if (typeof descriptor.get === 'function') {
+      fnKey = 'get';
+      fn = descriptor.get;
+    }
+
+    if (!fn) {
+      throw new Error('not supported');
+    }
+
+    const memoizeKey = `${memoizeKeyPrefix}:${key}`;
+    descriptor[fnKey!] = function (...args: any[]) {
+      self = this;
+
+      if (!this.hasOwnProperty(memoizeKey)) {
+        Object.defineProperty(this, memoizeKey, {
+          configurable: true,
+          enumerable: false,
+          writable: true,
+          value: fn!.apply(this, args),
+        });
+      }
+
+      return this[memoizeKey];
+    };
+  };
+
+  result.clear = () => {
+    if (typeof self === 'undefined') {
+      return;
+    }
+    Object.getOwnPropertyNames(self).forEach((property) => {
+      if (property.indexOf(memoizeKeyPrefix) === 0) {
+        delete self[property];
+      }
+    });
+  };
+
+  return result;
+}
+
+export function memoize(target: any, key: string, descriptor: any) {
+  return createMemoizer()(target, key, descriptor);
+}
+
+export type IDebounceReducer<T> = (previousValue: T, ...args: any[]) => T;
+
+export function debounce<T>(delay: number, reducer?: IDebounceReducer<T>, initialValueProvider?: () => T): Function {
+  return createDecorator((fn, key) => {
+    const timerKey = `$debounce$${key}`;
+    const resultKey = `$debounce$result$${key}`;
+
+    return function (this: any, ...args: any[]) {
+      if (!this[resultKey]) {
+        this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
+      }
+
+      clearTimeout(this[timerKey]);
+
+      if (reducer) {
+        this[resultKey] = reducer(this[resultKey], ...args);
+        args = [this[resultKey]];
+      }
+
+      this[timerKey] = setTimeout(() => {
+        fn.apply(this, args);
+        this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
+      }, delay);
+    };
+  });
+}
+
+export function throttle<T>(delay: number, reducer?: IDebounceReducer<T>, initialValueProvider?: () => T): Function {
+  return createDecorator((fn, key) => {
+    const timerKey = `$throttle$timer$${key}`;
+    const resultKey = `$throttle$result$${key}`;
+    const lastRunKey = `$throttle$lastRun$${key}`;
+    const pendingKey = `$throttle$pending$${key}`;
+
+    return function (this: any, ...args: any[]) {
+      if (!this[resultKey]) {
+        this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
+      }
+      if (this[lastRunKey] === null || this[lastRunKey] === undefined) {
+        this[lastRunKey] = -Number.MAX_VALUE;
+      }
+
+      if (reducer) {
+        this[resultKey] = reducer(this[resultKey], ...args);
+      }
+
+      if (this[pendingKey]) {
+        return;
+      }
+
+      const nextTime = this[lastRunKey] + delay;
+      if (nextTime <= Date.now()) {
+        this[lastRunKey] = Date.now();
+        fn.apply(this, [this[resultKey]]);
+        this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
+      } else {
+        this[pendingKey] = true;
+        this[timerKey] = setTimeout(() => {
+          this[pendingKey] = false;
+          this[lastRunKey] = Date.now();
+          fn.apply(this, [this[resultKey]]);
+          this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
+        }, nextTime - Date.now());
+      }
+    };
+  });
+}
+
+export function es5ClassCompat(target: any): any {
+  function _() {
+    // @ts-ignore
+    return Reflect.construct(target, arguments, this.constructor);
+  }
+  Object.defineProperty(_, 'name', Object.getOwnPropertyDescriptor(target, 'name')!);
+  Object.setPrototypeOf(_, target);
+  Object.setPrototypeOf(_.prototype, target.prototype);
+  return _;
+}