@difizen/libro-common 0.3.3 → 1.0.0

package/src/common/path.ts

@@ -0,0 +1,226 @@
+export class Path {
+  static separator = '/';
+
+  static isDrive(segment: string): boolean {
+    return segment.endsWith(':');
+  }
+
+  /**
+   * vscode-uri always normalizes drive letters to lower case:
+   * https://github.com/Microsoft/vscode-uri/blob/b1d3221579f97f28a839b6f996d76fc45e9964d8/src/index.ts#L1025
+   */
+  static normalizeDrive(path: string): string {
+    if (path.length > 3 && path[0] === '/' && path[2] === ':') {
+      const code = path.charCodeAt(1);
+      if (code >= 65 && code <= 90) {
+        path = `/${path[1].toLowerCase()}:${path.substring(3)}`;
+      }
+      return path;
+    }
+    if (path.length > 2 && path[1] === ':') {
+      const code = path.charCodeAt(0);
+      if (code >= 65 && code <= 90) {
+        path = `${path[0].toLowerCase()}:${path.substring(2)}`;
+      }
+      if (path[0] !== '/') {
+        path = `/${path}`;
+      }
+    }
+    return path;
+  }
+  /**
+   * Normalize path separator to use Path.separator
+   * @param Path candidate to normalize
+   * @returns Normalized string path
+   */
+  static normalizePathSeparator(path: string): string {
+    return path.split(/[\\]/).join(Path.separator);
+  }
+
+  static normalizePath(path: string): string {
+    return Path.normalizeDrive(Path.normalizePathSeparator(path));
+  }
+
+  readonly isAbsolute: boolean;
+
+  get isRelative(): boolean {
+    return !this.isAbsolute;
+  }
+
+  readonly isRoot: boolean;
+  readonly isDrive: boolean;
+  readonly root: Path | undefined;
+  readonly base: string;
+  readonly name: string;
+  readonly ext: string;
+
+  private _dir: Path | undefined;
+  private readonly raw: string;
+
+  /**
+   * The raw should be normalized, meaning that only '/' is allowed as a path separator.
+   */
+  constructor(raw: string) {
+    this.raw = Path.normalizePath(raw);
+    const lastIndex = this.raw.lastIndexOf(Path.separator);
+    this.isAbsolute = this.raw.indexOf(Path.separator) === 0;
+    this.base = lastIndex === -1 ? this.raw : this.raw.substring(lastIndex + 1);
+    this.isDrive = Path.isDrive(this.base);
+    this.isRoot = this.isAbsolute && lastIndex === 0 && (!this.base || this.isDrive);
+    this.root = Path.toRoot(this);
+
+    const extIndex = this.base.lastIndexOf('.');
+    this.name = extIndex === -1 ? this.base : this.base.substring(0, extIndex);
+    this.ext = extIndex === -1 ? '' : this.base.substring(extIndex);
+  }
+
+  /**
+   * Returns the parent directory if it exists (`hasDir === true`) or `this` otherwise.
+   */
+  get dir(): Path {
+    if (this._dir === undefined) {
+      this._dir = this.doGetDir();
+    }
+    return this._dir;
+  }
+
+  /**
+   * Returns `true` if this has a parent directory, `false` otherwise.
+   *
+   * _This implementation returns `true` if and only if this is not the root dir and
+   * there is a path separator in the raw path._
+   */
+  get hasDir(): boolean {
+    return !this.isRoot && this.raw.lastIndexOf(Path.separator) !== -1;
+  }
+
+  protected doGetDir(): Path {
+    if (!this.hasDir) {
+      return this;
+    }
+    const lastIndex = this.raw.lastIndexOf(Path.separator);
+    if (this.isAbsolute) {
+      const firstIndex = this.raw.indexOf(Path.separator);
+      if (firstIndex === lastIndex) {
+        return new Path(this.raw.substr(0, firstIndex + 1));
+      }
+    }
+    return new Path(this.raw.substr(0, lastIndex));
+  }
+
+  includes(path: Path): boolean {
+    return !!Path.relative(this, path);
+  }
+
+  toString(): string {
+    return this.raw;
+  }
+
+  static toRoot(path: Path): Path | undefined {
+    // '/' -> '/'
+    // '/c:' -> '/c:'
+    if (path.isRoot) {
+      return path;
+    }
+
+    // 'foo/bar' -> `undefined`
+    if (path.isRelative) {
+      return undefined;
+    }
+
+    const index = path.raw.indexOf(Path.separator, Path.separator.length);
+
+    if (index === -1) {
+      // '/foo/bar' -> '/'
+      return new Path(Path.separator);
+    }
+
+    // '/c:/foo/bar' -> '/c:'
+    // '/foo/bar' -> '/'
+    return new Path(path.raw.substring(0, index)).root;
+  }
+
+  static join(path: Path, ...paths: string[]): Path {
+    const relativePath = paths.filter((s) => !!s).join(Path.separator);
+    if (!relativePath) {
+      return path;
+    }
+    if (path.raw.endsWith(Path.separator)) {
+      return new Path(path.raw + relativePath);
+    }
+    return new Path(path.raw + Path.separator + relativePath);
+  }
+
+  /**
+   *
+   * @param paths portions of a path
+   * @returns a new Path if an absolute path can be computed from the segments passed in + this.raw
+   * If no absolute path can be computed, returns undefined.
+   *
+   * Processes the path segments passed in from right to left (reverse order) concatenating until an
+   * absolute path is found.
+   */
+  static resolve(path: Path, ...paths: string[]): Path | undefined {
+    const segments = paths.slice().reverse(); // Don't mutate the caller's array.
+    segments.push(path.raw);
+    let result = new Path('');
+    for (const segment of segments) {
+      if (segment) {
+        const next = Path.join(new Path(segment), result.raw);
+        if (next.isAbsolute) {
+          return Path.normalize(next);
+        }
+        result = next;
+      }
+    }
+    return undefined;
+  }
+
+  static relative(base: Path, path: Path): Path | undefined {
+    if (base.raw === path.raw) {
+      return new Path('');
+    }
+    if (!base.raw || !path.raw) {
+      return undefined;
+    }
+    const raw = base.base ? base.raw + Path.separator : base.raw;
+    if (!path.raw.startsWith(raw)) {
+      return undefined;
+    }
+    const relativePath = path.raw.substr(raw.length);
+    return new Path(relativePath);
+  }
+
+  /*
+   * return a normalized Path, resolving '..' and '.' segments
+   */
+  static normalize(path: Path): Path {
+    const trailingSlash = path.raw.endsWith('/');
+    const pathArray = path.toString().split('/');
+    const resultArray: string[] = [];
+    pathArray.forEach((value) => {
+      if (!value || value === '.') {
+        return;
+      }
+      if (value === '..') {
+        if (resultArray.length && resultArray[resultArray.length - 1] !== '..') {
+          resultArray.pop();
+        } else if (path.isRelative) {
+          resultArray.push('..');
+        }
+      } else {
+        resultArray.push(value);
+      }
+    });
+    if (resultArray.length === 0) {
+      if (path.isRoot) {
+        return new Path('/');
+      } else {
+        return new Path('.');
+      }
+    }
+    return new Path(
+      (path.isAbsolute ? '/' : '') + resultArray.join('/') + (trailingSlash ? '/' : ''),
+    );
+  }
+}

package/src/common/platform.ts

@@ -0,0 +1,281 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+const LANGUAGE_DEFAULT = 'en';
+
+let _isWindows = false;
+let _isMacintosh = false;
+let _isLinux = false;
+let _isLinuxSnap = false;
+let _isNative = false;
+let _isWeb = false;
+let _isIOS = false;
+let _locale: string | undefined;
+let _language: string = LANGUAGE_DEFAULT;
+let _translationsConfigFile: string | undefined;
+let _userAgent: string | undefined;
+
+let _isIE = false;
+let _isEdge = false;
+let _isOpera = false;
+let _isFirefox = false;
+let _isWebKit = false;
+let _isChrome = true;
+let _isSafari = false;
+let _isIPad = false;
+
+interface NLSConfig {
+  locale: string;
+  availableLanguages: Record<string, string>;
+  _translationsConfigFile: string;
+}
+
+export type IProcessEnvironment = Record<string, string>;
+
+export interface INodeProcess {
+  platform: 'win32' | 'linux' | 'darwin';
+  env: IProcessEnvironment;
+  nextTick: () => void;
+  versions?: {
+    electron?: string;
+  };
+  sandboxed?: boolean; // Electron
+  type?: string;
+  cwd: () => string;
+}
+declare const process: INodeProcess;
+declare const global: any;
+
+interface INavigator {
+  userAgent: string;
+  language: string;
+  maxTouchPoints?: number;
+}
+declare const navigator: INavigator;
+declare const self: any;
+
+const _globals =
+  typeof self === 'object' ? self : typeof global === 'object' ? global : ({} as any);
+
+let nodeProcess: INodeProcess | undefined;
+if (typeof process !== 'undefined') {
+  // Native environment (non-sandboxed)
+  nodeProcess = process;
+} else if (typeof _globals.vscode !== 'undefined') {
+  // Native environment (sandboxed)
+  nodeProcess = _globals.vscode.process;
+}
+
+const isElectronRenderer =
+  typeof nodeProcess?.versions?.electron === 'string' &&
+  nodeProcess.type === 'renderer';
+export const isElectronSandboxed = isElectronRenderer && nodeProcess?.sandboxed;
+export const browserCodeLoadingCacheStrategy:
+  | 'none'
+  | 'code'
+  | 'bypassHeatCheck'
+  | 'bypassHeatCheckAndEagerCompile'
+  | undefined = (() => {
+  // Always enabled when sandbox is enabled
+  if (isElectronSandboxed) {
+    return 'bypassHeatCheck';
+  }
+
+  // Otherwise, only enabled conditionally
+  const env = nodeProcess?.env['ENABLE_VSCODE_BROWSER_CODE_LOADING'];
+  if (typeof env === 'string') {
+    if (
+      env === 'none' ||
+      env === 'code' ||
+      env === 'bypassHeatCheck' ||
+      env === 'bypassHeatCheckAndEagerCompile'
+    ) {
+      return env;
+    }
+
+    return 'bypassHeatCheck';
+  }
+
+  return undefined;
+})();
+export const isPreferringBrowserCodeLoad =
+  typeof browserCodeLoadingCacheStrategy === 'string';
+
+// Web environment
+if (typeof navigator === 'object' && !isElectronRenderer) {
+  _userAgent = navigator.userAgent;
+  _isWindows = _userAgent.indexOf('Windows') >= 0;
+  _isMacintosh = _userAgent.indexOf('Macintosh') >= 0;
+  _isIOS =
+    (_userAgent.indexOf('Macintosh') >= 0 ||
+      _userAgent.indexOf('iPad') >= 0 ||
+      _userAgent.indexOf('iPhone') >= 0) &&
+    !!navigator.maxTouchPoints &&
+    navigator.maxTouchPoints > 0;
+  _isLinux = _userAgent.indexOf('Linux') >= 0;
+  _isWeb = true;
+  _locale = ((navigator as any).languages as string)
+    ? ((navigator as any).languages[0] as string)
+    : navigator.language || ((navigator as any).userLanguage as string);
+  _language = _locale;
+  _isIE = _userAgent.indexOf('Trident') >= 0;
+  _isEdge = _userAgent.indexOf('Edge/') >= 0;
+  _isOpera = _userAgent.indexOf('Opera') >= 0;
+  _isFirefox = _userAgent.indexOf('Firefox') >= 0;
+  _isWebKit = _userAgent.indexOf('AppleWebKit') >= 0;
+  _isChrome = _userAgent.indexOf('Chrome') >= 0;
+  _isSafari = _userAgent.indexOf('Chrome') === -1 && _userAgent.indexOf('Safari') >= 0;
+  _isIPad = _userAgent.indexOf('iPad') >= 0;
+}
+
+// Native environment
+else if (typeof nodeProcess === 'object') {
+  _isWindows = nodeProcess.platform === 'win32';
+  _isMacintosh = nodeProcess.platform === 'darwin';
+  _isLinux = nodeProcess.platform === 'linux';
+  _isLinuxSnap =
+    _isLinux && !!nodeProcess.env['SNAP'] && !!nodeProcess.env['SNAP_REVISION'];
+  _locale = LANGUAGE_DEFAULT;
+  _language = LANGUAGE_DEFAULT;
+  const rawNlsConfig = nodeProcess.env['VSCODE_NLS_CONFIG'];
+  if (rawNlsConfig) {
+    try {
+      const nlsConfig: NLSConfig = JSON.parse(rawNlsConfig);
+      const resolved = nlsConfig.availableLanguages['*'];
+      _locale = nlsConfig.locale;
+      // VSCode's default language is 'en'
+      _language = resolved || LANGUAGE_DEFAULT;
+      _translationsConfigFile = nlsConfig._translationsConfigFile;
+    } catch (e) {
+      //
+    }
+  }
+  _isNative = true;
+}
+
+// Unknown environment
+else {
+  console.error('Unable to resolve platform.');
+}
+
+export enum Platform {
+  Web,
+  Mac,
+  Linux,
+  Windows,
+}
+export function PlatformToString(platform: Platform) {
+  switch (platform) {
+    case Platform.Web:
+      return 'Web';
+    case Platform.Mac:
+      return 'Mac';
+    case Platform.Linux:
+      return 'Linux';
+    case Platform.Windows:
+      return 'Windows';
+  }
+}
+
+let _platform: Platform = Platform.Web;
+if (_isMacintosh) {
+  _platform = Platform.Mac;
+} else if (_isWindows) {
+  _platform = Platform.Windows;
+} else if (_isLinux) {
+  _platform = Platform.Linux;
+}
+
+export const isWindows = _isWindows;
+export const isMacintosh = _isMacintosh;
+export const isOSX = _isMacintosh;
+export const isLinux = _isLinux;
+export const isLinuxSnap = _isLinuxSnap;
+export const isNative = _isNative;
+export const isWeb = _isWeb;
+export const isIOS = _isIOS;
+export const platform = _platform;
+export const userAgent = _userAgent;
+
+export const isIE = _isIE;
+export const isEdge = _isEdge;
+export const isEdgeOrIE = isIE || isEdge;
+export const isOpera = _isOpera;
+export const isFirefox = _isFirefox;
+export const isWebKit = _isWebKit;
+export const isChrome = _isChrome;
+export const isSafari = _isSafari;
+export const isIPad = _isIPad;
+
+/**
+ * The language used for the user interface. The format of
+ * the string is all lower case (e.g. zh-tw for Traditional
+ * Chinese)
+ */
+export const language = _language;
+
+export namespace Language {
+  export function value(): string {
+    return language;
+  }
+
+  export function isDefaultVariant(): boolean {
+    if (language.length === 2) {
+      return language === 'en';
+    }
+    if (language.length >= 3) {
+      return language[0] === 'e' && language[1] === 'n' && language[2] === '-';
+    }
+    return false;
+  }
+
+  export function isDefault(): boolean {
+    return language === 'en';
+  }
+}
+
+/**
+ * The OS locale or the locale specified by --locale. The format of
+ * the string is all lower case (e.g. zh-tw for Traditional
+ * Chinese). The UI is not necessarily shown in the provided locale.
+ */
+export const locale = _locale;
+
+/**
+ * The translatios that are available through language packs.
+ */
+export const translationsConfigFile = _translationsConfigFile;
+
+export const globals: any = _globals;
+
+export enum OperatingSystem {
+  Windows = 1,
+  Macintosh = 2,
+  Linux = 3,
+}
+export const OS =
+  _isMacintosh || _isIOS
+    ? OperatingSystem.Macintosh
+    : _isWindows
+      ? OperatingSystem.Windows
+      : OperatingSystem.Linux;
+
+let _isLittleEndian = true;
+let _isLittleEndianComputed = false;
+export function isLittleEndian(): boolean {
+  if (!_isLittleEndianComputed) {
+    _isLittleEndianComputed = true;
+    const test = new Uint8Array(2);
+    test[0] = 1;
+    test[1] = 2;
+    const view = new Uint16Array(test.buffer);
+    _isLittleEndian = view[0] === (2 << 8) + 1;
+  }
+  return _isLittleEndian;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isBasicWasmSupported =
+  isWeb && typeof (window as any).WebAssembly !== 'undefined';

package/src/common/priority.ts

@@ -0,0 +1,79 @@
+import type { MaybeArray } from './types';
+
+import type { MaybePromise } from '.';
+
+export enum Priority {
+  PRIOR = 1000,
+  DEFAULT = 100,
+  IDLE = -1,
+}
+
+export namespace Priority {
+  export type PriorityObject<T> = {
+    readonly priority: number;
+    readonly value: T;
+  };
+  export type GetPriority<T> = (value: T) => MaybePromise<number>;
+  export type GetPrioritySync<T> = (value: T) => number;
+
+  export function isValid<T>(p: PriorityObject<T>): boolean {
+    return p.priority > 0;
+  }
+  export function compare<T>(p: PriorityObject<T>, p2: PriorityObject<T>): number {
+    return p2.priority - p.priority;
+  }
+
+  export async function toPriorityObject<T>(
+    rawValue: T,
+    getPriority: GetPriority<T>,
+  ): Promise<PriorityObject<T>>;
+  export async function toPriorityObject<T>(
+    rawValue: T[],
+    getPriority: GetPriority<T>,
+  ): Promise<PriorityObject<T>[]>;
+  export async function toPriorityObject<T>(
+    rawValue: MaybeArray<T>,
+    getPriority: GetPriority<T>,
+  ): Promise<MaybeArray<PriorityObject<T>>> {
+    if (rawValue instanceof Array) {
+      return Promise.all(rawValue.map((v) => toPriorityObject(v, getPriority)));
+    }
+    const value = rawValue;
+    const priority = await getPriority(value);
+    return { priority, value };
+  }
+  export async function sort<T>(
+    values: T[],
+    getPriority: GetPriority<T>,
+  ): Promise<PriorityObject<T>[]> {
+    const prioritizeable = await toPriorityObject(values, getPriority);
+    return prioritizeable.filter(isValid).sort(compare);
+  }
+
+  export function toPriorityObjectSync<T>(
+    rawValue: T,
+    getPriority: GetPrioritySync<T>,
+  ): PriorityObject<T>;
+  export function toPriorityObjectSync<T>(
+    rawValue: T[],
+    getPriority: GetPrioritySync<T>,
+  ): PriorityObject<T>[];
+  export function toPriorityObjectSync<T>(
+    rawValue: MaybeArray<T>,
+    getPriority: GetPrioritySync<T>,
+  ): MaybeArray<PriorityObject<T>> {
+    if (rawValue instanceof Array) {
+      return rawValue.map((v) => toPriorityObjectSync(v, getPriority));
+    }
+    const value = rawValue;
+    const priority = getPriority(value);
+    return { priority, value };
+  }
+  export function sortSync<T>(
+    values: T[],
+    getPriority: GetPrioritySync<T>,
+  ): PriorityObject<T>[] {
+    const prioritizeable = toPriorityObjectSync(values, getPriority);
+    return prioritizeable.filter(isValid).sort(compare);
+  }
+}

package/src/common/promise-util.spec.ts

@@ -0,0 +1,68 @@
+import assert from 'assert';
+
+import { timeout, retry } from '.';
+import { CancellationTokenSource } from '.';
+import { Deferred } from '.';
+
+describe('promise util', () => {
+  it('#timeout', async () => {
+    const source = new CancellationTokenSource();
+    const res = await timeout(50, source.token);
+    assert(res === undefined);
+  });
+  it('#timeout cancel', async () => {
+    const source = new CancellationTokenSource();
+    const doneDeferred = new Deferred<void>();
+    timeout(100, source.token).catch((ex) => {
+      assert(!!ex);
+      doneDeferred.resolve();
+    });
+    setTimeout(() => {
+      source.cancel();
+    }, 50);
+    await doneDeferred.promise;
+  });
+  it('#retry', async () => {
+    let errorTime = 0;
+    let retryTimes = 0;
+    const task = async () => {
+      const deferred = new Deferred<void>();
+      setTimeout(() => {
+        if (errorTime < 2) {
+          deferred.reject();
+          errorTime += 1;
+          retryTimes += 1;
+        } else {
+          retryTimes += 1;
+          deferred.resolve();
+        }
+      }, 50);
+      return deferred.promise;
+    };
+    await retry(task, 50, 3);
+    expect(retryTimes).toBe(3);
+  });
+  it('#retry last error', async () => {
+    let errorTime = 0;
+    const start = new Date().getTime();
+    const task = async () => {
+      const deferred = new Deferred<void>();
+      setTimeout(() => {
+        if (errorTime < 4) {
+          deferred.reject();
+          errorTime += 1;
+        } else {
+          deferred.resolve();
+        }
+      }, 50);
+      return deferred.promise;
+    };
+    try {
+      await retry(task, 50, 3);
+    } catch (ex) {
+      const end = new Date().getTime();
+      assert(end - start > 300);
+      assert(end - start < 400);
+    }
+  });
+});

package/src/common/promise-util.ts

@@ -0,0 +1,34 @@
+import { CancellationToken, cancelled } from './cancellation';
+import { Deferred } from './deferred';
+
+/**
+ * @returns resolves after a specified number of milliseconds
+ * @throws cancelled if a given token is cancelled before a specified number of milliseconds
+ */
+export function timeout(ms: number, token = CancellationToken.None): Promise<void> {
+  const deferred = new Deferred<void>();
+  const handle = setTimeout(() => deferred.resolve(), ms);
+  token.onCancellationRequested(() => {
+    clearTimeout(handle);
+    deferred.reject(cancelled());
+  });
+  return deferred.promise;
+}
+
+export async function retry<T>(
+  task: () => Promise<T>,
+  delay: number,
+  retries: number,
+): Promise<T | undefined> {
+  let lastError: Error | undefined;
+
+  for (let i = 0; i < retries; i += 1) {
+    try {
+      return await task();
+    } catch (error: any) {
+      lastError = error;
+      await timeout(delay);
+    }
+  }
+  throw lastError;
+}