@opensumi/ide-utils 2.21.13 → 2.22.0

package/src/types.ts

@@ -0,0 +1,214 @@
+const _typeof = {
+  number: 'number',
+  string: 'string',
+  undefined: 'undefined',
+  object: 'object',
+  function: 'function',
+};
+
+/**
+ * @returns whether the provided parameter is a JavaScript Array or not.
+ */
+export function isArray(array: any): array is any[] {
+  if (Array.isArray) {
+    return Array.isArray(array);
+  }
+
+  if (array && typeof array.length === _typeof.number && array.constructor === Array) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * @returns whether the provided parameter is a JavaScript String or not.
+ */
+export function isString(str: any): str is string {
+  if (typeof str === _typeof.string || str instanceof String) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * @returns whether the provided parameter is a JavaScript Array and each element in the array is a string.
+ */
+export function isStringArray(value: any): value is string[] {
+  return isArray(value) && value.every((elem) => isString(elem));
+}
+
+/**
+ *
+ * @returns whether the provided parameter is of type `object` but **not**
+ *	`null`, an `array`, a `regexp`, nor a `date`.
+ */
+export function isObject(obj: any): obj is Object {
+  // The method can't do a type cast since there are type (like strings) which
+  // are subclasses of any put not positvely matched by the function. Hence type
+  // narrowing results in wrong results.
+  return (
+    typeof obj === _typeof.object &&
+    obj !== null &&
+    !Array.isArray(obj) &&
+    !(obj instanceof RegExp) &&
+    !(obj instanceof Date)
+  );
+}
+
+/**
+ * In **contrast** to just checking `typeof` this will return `false` for `NaN`.
+ * @returns whether the provided parameter is a JavaScript Number or not.
+ */
+export function isNumber(obj: any): obj is number {
+  if ((typeof obj === _typeof.number || obj instanceof Number) && !isNaN(obj)) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * @returns whether the provided parameter is a JavaScript Boolean or not.
+ */
+export function isBoolean(obj: any): obj is boolean {
+  return obj === true || obj === false;
+}
+
+/**
+ * @returns whether the provided parameter is undefined.
+ */
+export function isUndefined(obj: any): obj is undefined {
+  return typeof obj === _typeof.undefined;
+}
+
+/**
+ * @returns whether the provided parameter is defined.
+ */
+export function isDefined<T>(arg: T | null | undefined): arg is T {
+  return !isUndefinedOrNull(arg);
+}
+
+/**
+ * @returns whether the provided parameter is undefined or null.
+ */
+export function isUndefinedOrNull(obj: any): obj is undefined | null {
+  return isUndefined(obj) || obj === null;
+}
+
+/**
+ * @returns whether the provided parameter is null.
+ */
+export function isNull(obj: any): obj is null {
+  return obj === null;
+}
+
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+export function hasProperty<X extends {}, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, unknown> {
+  return prop in obj;
+}
+
+/**
+ * @returns whether the provided parameter is an empty JavaScript Object or not.
+ */
+export function isEmptyObject(obj: any): obj is any {
+  if (!isObject(obj)) {
+    return false;
+  }
+
+  for (const key in obj) {
+    if (hasOwnProperty.call(obj, key)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * @returns whether the provided parameter is a JavaScript Function or not.
+ */
+export function isFunction<T extends Function>(obj: any): obj is T {
+  return typeof obj === _typeof.function;
+}
+
+/**
+ * @returns whether the provided parameters is are JavaScript Function or not.
+ */
+export function areFunctions(...objects: any[]): boolean {
+  return objects.length > 0 && objects.every(isFunction);
+}
+
+export type TypeConstraint = string | Function;
+
+export function validateConstraints(args: any[], constraints: Array<TypeConstraint | undefined>): void {
+  const len = Math.min(args.length, constraints.length);
+  for (let i = 0; i < len; i++) {
+    validateConstraint(args[i], constraints[i]);
+  }
+}
+
+export function validateConstraint(arg: any, constraint: TypeConstraint | undefined): void {
+  if (isString(constraint)) {
+    if (typeof arg !== constraint) {
+      throw new Error(`argument does not match constraint: typeof ${constraint}`);
+    }
+  } else if (isFunction(constraint)) {
+    try {
+      if (arg instanceof constraint) {
+        return;
+      }
+    } catch (_e) {
+      // ignore
+    }
+    if (!isUndefinedOrNull(arg) && arg.constructor === constraint) {
+      return;
+    }
+    if (constraint.length === 1 && constraint.call(undefined, arg) === true) {
+      return;
+    }
+    throw new Error(
+      'argument does not match one of these constraints: arg instanceof constraint, arg.constructor === constraint, nor constraint(arg) === true',
+    );
+  }
+}
+
+/**
+ * 混入对象值
+ * @export
+ * @param {*} destination
+ * @param {*} source
+ * @param {boolean} [overwrite=true] 是否深度混入
+ * @returns {*}
+ */
+export function mixin(destination: any, source: any, overwrite = true): any {
+  if (!isObject(destination)) {
+    return source;
+  }
+
+  if (isObject(source)) {
+    Object.keys(source).forEach((key) => {
+      if (key in destination) {
+        if (overwrite) {
+          if (isObject(destination[key]) && isObject(source[key])) {
+            mixin(destination[key], source[key], overwrite);
+          } else {
+            destination[key] = source[key];
+          }
+        }
+      } else {
+        destination[key] = source[key];
+      }
+    });
+  }
+  return destination;
+}
+
+/**
+ * Converts null to undefined, passes all other values through.
+ */
+export function withNullAsUndefined<T>(x: T | null): T | undefined {
+  return x === null ? undefined : x;
+}

package/src/uint.ts

@@ -0,0 +1,59 @@
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export const enum Constants {
+  /**
+   * MAX SMI (SMall Integer) as defined in v8.
+   * one bit is lost for boxing/unboxing flag.
+   * one bit is lost for sign flag.
+   * See https://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/#tagged-values
+   */
+  MAX_SAFE_SMALL_INTEGER = 1 << 30,
+
+  /**
+   * MIN SMI (SMall Integer) as defined in v8.
+   * one bit is lost for boxing/unboxing flag.
+   * one bit is lost for sign flag.
+   * See https://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/#tagged-values
+   */
+  MIN_SAFE_SMALL_INTEGER = -(1 << 30),
+
+  /**
+   * Max unsigned integer that fits on 8 bits.
+   */
+  MAX_UINT_8 = 255, // 2^8 - 1
+
+  /**
+   * Max unsigned integer that fits on 16 bits.
+   */
+  MAX_UINT_16 = 65535, // 2^16 - 1
+
+  /**
+   * Max unsigned integer that fits on 32 bits.
+   */
+  MAX_UINT_32 = 4294967295, // 2^32 - 1
+
+  UNICODE_SUPPLEMENTARY_PLANE_BEGIN = 0x010000,
+}
+
+export function toUint8(v: number): number {
+  if (v < 0) {
+    return 0;
+  }
+  if (v > Constants.MAX_UINT_8) {
+    return Constants.MAX_UINT_8;
+  }
+  return v | 0;
+}
+
+export function toUint32(v: number): number {
+  if (v < 0) {
+    return 0;
+  }
+  if (v > Constants.MAX_UINT_32) {
+    return Constants.MAX_UINT_32;
+  }
+  return v | 0;
+}

package/src/uri.ts

@@ -0,0 +1,298 @@
+import { URI as Uri } from 'vscode-uri';
+
+import { IRelativePattern, match } from './glob';
+import { Path } from './path';
+
+export { URI as Uri, Utils as UriUtils } from 'vscode-uri';
+// 3.0 的 vscode-uri 没有导出这个
+export interface UriComponents {
+  scheme: string;
+  authority: string;
+  path: string;
+  query: string;
+  fragment: string;
+}
+
+export class URI {
+  static from(components: { scheme: string; authority?: string; path?: string; query?: string; fragment?: string }) {
+    return new URI(Uri.from(components));
+  }
+
+  static file(path: string) {
+    return new URI(Uri.file(path));
+  }
+
+  static parse(path: string) {
+    return new URI(Uri.parse(path));
+  }
+
+  static isUri(thing: any): thing is URI {
+    if (thing instanceof URI) {
+      return true;
+    }
+    if (!thing) {
+      return false;
+    }
+    return Uri.isUri(thing);
+  }
+
+  static isUriString(str: string): boolean {
+    return !!str && /^[A-Za-z\-\_]+:\/\//.test(str);
+  }
+
+  static revive(data: any) {
+    return Uri.revive(data);
+  }
+
+  public readonly codeUri: Uri;
+  private _path: Path | undefined;
+
+  constructor(uri: string | Uri = '') {
+    if (Uri.isUri(uri)) {
+      this.codeUri = uri;
+    } else {
+      this.codeUri = Uri.parse(uri);
+    }
+  }
+
+  get displayName(): string {
+    const base = this.path.base;
+    if (base) {
+      return base;
+    }
+    if (this.path.isRoot) {
+      return this.path.toString();
+    }
+    return '';
+  }
+
+  /**
+   * Return all uri from the current to the top most.
+   */
+  get allLocations(): URI[] {
+    const locations: any[] = [];
+    let location: URI = this;
+    while (!location.path.isRoot) {
+      locations.push(location);
+      location = location.parent;
+    }
+    locations.push(location);
+    return locations;
+  }
+
+  get parent(): URI {
+    if (this.path.isRoot) {
+      return this;
+    }
+    return this.withPath(this.path.dir);
+  }
+
+  relative(uri: URI): Path | undefined {
+    if (this.authority !== uri.authority || this.scheme !== uri.scheme) {
+      return undefined;
+    }
+    return this.path.relative(uri.path);
+  }
+
+  resolve(path: string | Path): URI {
+    return this.withPath(this.path.join(path.toString()));
+  }
+
+  /**
+   * return a new URI replacing the current with the given scheme
+   */
+  withScheme(scheme: string): URI {
+    const newCodeUri = Uri.from({
+      ...this.codeUri.toJSON(),
+      scheme,
+    });
+    return new URI(newCodeUri);
+  }
+
+  /**
+   * @deprecated
+   * return this URI without a scheme
+   */
+  withoutScheme(): URI {
+    /**
+     * 本方法已废弃
+     * 由于 vscode-uri 自 1.0.8 起，内部强制校验和修正 `scheme` 参数
+     * 会将 scheme 为空时强制修正为 `file` (不可关闭)
+     * 会在不传入 scheme 时报错 (可通过 setUriThrowOnMissingScheme 关闭)
+     * 因此这里直接调用 `new Uri` 产生一个不带 scheme 的 Uri 实例
+     * ---- !!!!!!! ATTENTION ----
+     * 这样做的影响是 Uri 的实例 toJSON 时没有 $mid 参数，会在通信序列化时无法传输
+     * ---- !!!!!!! ATTENTION ----
+     * 但是 vscode-uri 对 constructor 属性加了 protected 保护，因此增加了 `ts-ignore`
+     */
+    if (process.env.NODE_ENV !== 'production' && console !== undefined) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        'Warning: `Uri.withoutScheme` is deprecated, ' +
+          'If you want to get `fsPath` by `withoutScheme` method, ' +
+          "it's recommended to use `uri.path.toString` directly",
+      );
+    }
+
+    // @ts-ignore
+    const newCodeUri = new Uri({
+      ...this.codeUri.toJSON(),
+      scheme: '',
+    });
+
+    return new URI(newCodeUri);
+  }
+
+  /**
+   * return a new URI replacing the current with the given authority
+   */
+  withAuthority(authority: string): URI {
+    const newCodeUri = Uri.from({
+      ...this.codeUri.toJSON(),
+      scheme: this.codeUri.scheme,
+      authority,
+    });
+    return new URI(newCodeUri);
+  }
+
+  /**
+   * return this URI without a authority
+   */
+  withoutAuthority(): URI {
+    return this.withAuthority('');
+  }
+
+  /**
+   * return a new URI replacing the current with the given path
+   */
+  withPath(path: string | Path): URI {
+    const newCodeUri = Uri.from({
+      ...this.codeUri.toJSON(),
+      scheme: this.codeUri.scheme,
+      path: path.toString(),
+    });
+    return new URI(newCodeUri);
+  }
+
+  /**
+   * return this URI without a path
+   */
+  withoutPath(): URI {
+    return this.withPath('');
+  }
+
+  /**
+   * return a new URI replacing the current with the given query
+   */
+  withQuery(query: string): URI {
+    const newCodeUri = Uri.from({
+      ...this.codeUri.toJSON(),
+      scheme: this.codeUri.scheme,
+      query,
+    });
+    return new URI(newCodeUri);
+  }
+
+  /**
+   * return this URI without a query
+   */
+  withoutQuery(): URI {
+    return this.withQuery('');
+  }
+
+  /**
+   * return a new URI replacing the current with the given fragment
+   */
+  withFragment(fragment: string): URI {
+    const newCodeUri = Uri.from({
+      ...this.codeUri.toJSON(),
+      scheme: this.codeUri.scheme,
+      fragment,
+    });
+    return new URI(newCodeUri);
+  }
+
+  /**
+   * return this URI without a fragment
+   */
+  withoutFragment(): URI {
+    return this.withFragment('');
+  }
+
+  get scheme(): string {
+    return this.codeUri.scheme;
+  }
+
+  get authority(): string {
+    return this.codeUri.authority;
+  }
+
+  get path(): Path {
+    if (this._path === undefined) {
+      this._path = new Path(this.codeUri.path);
+    }
+    return this._path;
+  }
+
+  get query(): string {
+    return this.codeUri.query;
+  }
+
+  get fragment(): string {
+    return this.codeUri.fragment;
+  }
+
+  toString(skipEncoding?: boolean) {
+    return this.codeUri.toString(skipEncoding);
+  }
+
+  isEqualOrParent(uri: URI): boolean {
+    return this.authority === uri.authority && this.scheme === uri.scheme && this.path.isEqualOrParent(uri.path);
+  }
+
+  isEqual(uri: URI): boolean {
+    return (
+      this.authority === uri.authority &&
+      this.scheme === uri.scheme &&
+      this.path.isEqual(uri.path) &&
+      this.query === uri.query
+    );
+  }
+
+  matchGlobPattern(pattern: string | IRelativePattern): boolean {
+    return match(pattern, this.path.toString());
+  }
+
+  static getDistinctParents(uris: URI[]): URI[] {
+    const result: URI[] = [];
+    uris.forEach((uri, i) => {
+      if (!uris.some((otherUri, index) => index !== i && otherUri.isEqualOrParent(uri))) {
+        result.push(uri);
+      }
+    });
+    return result;
+  }
+
+  getParsedQuery(): { [key: string]: string } {
+    const queryString = this.query;
+    const query = {};
+    const pairs = (queryString[0] === '?' ? queryString.substr(1) : queryString).split('&');
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let i = 0; i < pairs.length; i++) {
+      const pair = pairs[i].split('=');
+      query[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1] || '');
+    }
+    return query;
+  }
+
+  static stringifyQuery(query: { [key: string]: any }): string {
+    const values: string[] = [];
+    Object.keys(query).forEach((key) => {
+      const value = encodeURIComponent(query[key]);
+      if (value !== undefined) {
+        values.push(encodeURIComponent(key) + '=' + value);
+      }
+    });
+    return values.join('&');
+  }
+}

package/src/uuid.ts

@@ -0,0 +1,6 @@
+// @ts-ignore
+import { nanoid } from 'nanoid';
+
+export function uuid(size?: number): string {
+  return nanoid(size);
+}