@api-client/core 0.3.6 → 0.3.7

package/src/lib/parsers/UrlParser.ts

@@ -0,0 +1,201 @@
+import { UrlValueParser, IUrlValueParserOptions } from './UrlValueParser.js';
+
+/**
+ * A class to parse URL string.
+ */
+export class UrlParser extends UrlValueParser {
+  /**
+   * @param value The URL value
+   */
+  constructor(value: string, opts?: IUrlValueParserOptions) {
+    super(opts);
+    this.value = value;
+  }
+
+  /**
+   * Returns protocol value in format `protocol` + ':'
+   *
+   * @return The value of the protocol or `undefined` if the value is not set
+   */
+  get protocol(): string | undefined {
+    return this.__data.protocol;
+  }
+
+  /**
+   * Sets value of the `protocol`
+   *
+   * @param value Protocol value.
+   */
+  set protocol(value: string | undefined) {
+    this.__data.protocol = value;
+  }
+
+  /**
+   * It reads the authority part of the URL value. It doesn't parses it
+   * to host, port and credentials parts.
+   *
+   * @return The value of the host or `undefined` if the value is not set
+   */
+  get host(): string | undefined {
+    return this.__data.host;
+  }
+
+  /**
+   * Sets value of the `host`
+   *
+   * @param value Host value.
+   */
+  set host(value: string | undefined) {
+    this.__data.host = value;
+  }
+
+  /**
+   * Returns path part of the URL.
+   *
+   * @returns The value of the path or `undefined` if the value not set
+   */
+  get path(): string | undefined {
+    return this.__data.path || '/';
+  }
+
+  /**
+   * Sets value of the `path`
+   *
+   * @param value Path value.
+   */
+  set path(value: string | undefined) {
+    this.__data.path = value;
+  }
+
+  /**
+   * Returns anchor part of the URL.
+   *
+   * @returns The value of the anchor or `undefined` if the value not set
+   */
+  get anchor(): string | undefined {
+    return this.__data.anchor;
+  }
+
+  /**
+   * Sets value of the `anchor`
+   *
+   * @param value The anchor value.
+   */
+  set anchor(value: string | undefined) {
+    this.__data.anchor = value;
+  }
+
+  /**
+   * Returns search part of the URL.
+   *
+   * @returns the value of the search or `undefined` if the value not set
+   */
+  get search(): string | undefined {
+    return this.__data.search;
+  }
+
+  /**
+   * Sets value of the `search`
+   *
+   * @param value Search value.
+   */
+  set search(value: string | undefined) {
+    this.__data.search = value;
+  }
+
+  /**
+   * The URL value. It is the same as calling `toString()`.
+   *
+   * @return The URL value for current configuration.
+   */
+  get value(): string {
+    return this.toString();
+  }
+
+  /**
+   * Sets value of the URL.
+   * It parses the url and sets properties.
+   *
+   * @param value The URL value.
+   */
+  set value(value: string) {
+    this.protocol = this._parseProtocol(value);
+    this.host = this._parseHost(value);
+    this.path = this._parsePath(value);
+    this.anchor = this._parseAnchor(value);
+    this.search = this._parseSearch(value);
+  }
+
+  /**
+   * Returns an array of search params.
+   *
+   * @returns The list of search params. Each item contains an
+   * array where the first item is the name of the parameter and the second item is the
+   * value.
+   */
+  get searchParams(): string[][] {
+    return this._parseSearchParams(this.search);
+  }
+
+  /**
+   * Sets the value of `search` and `searchParams`.
+   *
+   * @param value Search params list.
+   */
+  set searchParams(value: string[][]) {
+    if (!value || !value.length) {
+      this.search = undefined;
+      return;
+    }
+    this.search = value.map((item) => {
+      let itemValue = item[1];
+      if (!item[0] && !itemValue) {
+        return '';
+      }
+      if (itemValue === undefined) {
+        itemValue = '';
+      } else if (typeof itemValue !== 'string') {
+        itemValue = String(itemValue);
+      }
+      return `${item[0]}=${itemValue}`;
+    })
+    .join(this.opts.queryDelimiter);
+  }
+
+  /**
+   * Returns the URL for current settings.
+   *
+   * @return The URL value.
+   */
+  toString(): string {
+    let result = '';
+    if (this.protocol) {
+      result += this.protocol;
+      result += '//';
+    }
+    if (this.host) {
+      result += this.host;
+    }
+    if (this.path) {
+      if (this.path === '/' && !this.host && !this.search && !this.anchor) {
+        // ???
+      } else {
+        if (this.path[0] !== '/') {
+          result += '/';
+        }
+        result += this.path;
+      }
+    } else if (this.search || this.anchor) {
+        result += '/';
+      }
+    if (this.search) {
+      const p = this.searchParams;
+      this.searchParams = p;
+      result += `?${this.search}`;
+    }
+    if (this.anchor) {
+      result += `#${this.anchor}`;
+    }
+    return result;
+  }
+}

package/src/lib/parsers/UrlValueParser.ts

@@ -0,0 +1,211 @@
+export interface IUrlValueParserOptions {
+  /**
+   * A query string delimiter to use when processing query parameters.
+   */
+  queryDelimiter?: string;
+}
+
+interface DataValues {
+  /**
+   * A protocol value in format `protocol` + ':'
+   */
+  protocol?: string;
+  /**
+   * The authority part of the URL value
+   */
+  host?: string;
+  /**
+   * Path part of the URL.
+   */
+  path?: string;
+  /**
+   * Anchor part of the URL.
+   */
+  anchor?: string;
+  /**
+   * Search part of the URL.
+   */
+  search?: string;
+  opts?: IUrlValueParserOptions | undefined;
+}
+
+/**
+ * Implements logic for parsing URL string.
+ */
+export class UrlValueParser {
+  protected __data: DataValues;
+
+  constructor(opts?: IUrlValueParserOptions) {
+    this.__data = {};
+    this.opts = opts;
+  }
+
+  /**
+   * @returns Class options.
+   */
+  get opts(): IUrlValueParserOptions {
+    return this.__data.opts || {
+      queryDelimiter: '&',
+    };
+  }
+
+  /**
+   * Sets parser options.
+   * Unknown options are ignored.
+   */
+  set opts(opts: IUrlValueParserOptions | undefined) {
+    const options = (opts || {}) as IUrlValueParserOptions;
+    this.__data.opts = {
+      queryDelimiter: options.queryDelimiter || '&'
+    };
+  }
+
+  /**
+   * Returns protocol value in format `protocol` + ':'
+   *
+   * @param value URL to parse.
+   * @return Value of the protocol or undefined if value not set
+   */
+  protected _parseProtocol(value: string): string | undefined {
+    if (!value) {
+      return undefined;
+    }
+    const delimiterIndex = value.indexOf('://');
+    if (delimiterIndex !== -1) {
+      return value.substring(0, delimiterIndex + 1);
+    }
+    return undefined;
+  }
+
+  /**
+   * Gets a host value from the url.
+   * It reads the whole authority value of given `value`. It doesn't parses it
+   * to host, port and
+   * credentials parts. For URL panel it's enough.
+   *
+   * @param value The URL to parse
+   * @return Value of the host or undefined.
+   */
+  protected _parseHost(value: string): string | undefined {
+    if (!value) {
+      return undefined;
+    }
+    let result = value;
+    const delimiterIndex = result.indexOf('://');
+    if (delimiterIndex !== -1) {
+      result = result.substring(delimiterIndex + 3);
+    }
+    if (!result) {
+      return undefined;
+    }
+    // We don't need specifics here (username, password, port)
+    const host = result.split('/')[0];
+    return host;
+  }
+
+  /**
+   * Parses the path part of the URL.
+   *
+   * @param value URL value
+   * @returns Path part of the URL
+   */
+  protected _parsePath(value: string): string | undefined {
+    if (!value) {
+      return undefined;
+    }
+    let result = value;
+    const isBasePath = result[0] === '/';
+    if (!isBasePath) {
+      const index = result.indexOf('://');
+      if (index !== -1) {
+        result = result.substring(index + 3);
+      }
+    }
+    let index = result.indexOf('?');
+    if (index !== -1) {
+      result = result.substring(0, index);
+    }
+    index = result.indexOf('#');
+    if (index !== -1) {
+      result = result.substring(0, index);
+    }
+    const lastIsSlash = result[result.length - 1] === '/';
+    const parts = result.split('/').filter((part) => !!part);
+    if (!isBasePath) {
+      parts.shift();
+    }
+    let path = `/${  parts.join('/')}`;
+    if (lastIsSlash && parts.length > 1) {
+      path += '/';
+    }
+    return path;
+  }
+
+  /**
+   * Returns query parameters string (without the '?' sign) as a whole.
+   *
+   * @param value The URL to parse
+   * @returns Value of the search string or undefined.
+   */
+  protected _parseSearch(value: string): string | undefined {
+    if (!value) {
+      return undefined;
+    }
+    let index = value.indexOf('?');
+    if (index === -1) {
+      return undefined;
+    }
+    const result = value.substring(index + 1);
+    index = result.indexOf('#');
+    if (index === -1) {
+      return result;
+    }
+    return result.substring(0, index);
+  }
+
+  /**
+   * Reads a value of the anchor (or hash) parameter without the `#` sign.
+   *
+   * @param value The URL to parse
+   * @returns Value of the anchor (hash) or undefined.
+   */
+  protected _parseAnchor(value: string): string | undefined {
+    if (!value) {
+      return undefined;
+    }
+    const index = value.indexOf('#');
+    if (index === -1) {
+      return undefined;
+    }
+    return value.substring(index + 1);
+  }
+
+  /**
+   * Returns an array of items where each item is an array where first
+   * item is param name and second is it's value. Both always strings.
+   *
+   * @param search Parsed search parameter
+   * @returns Always returns an array.
+   */
+  protected _parseSearchParams(search?: string): string[][] {
+    const result: string[][] = [];
+    if (!search) {
+      return result;
+    }
+    const parts = search.split(this.opts.queryDelimiter as string);
+    parts.forEach((item) => {
+      const _part = ['', ''];
+      const _params = item.split('=');
+      let _name = _params.shift();
+      if (!_name && _name !== '') {
+        return;
+      }
+      _name = _name.trim();
+      const _value = _params.join('=').trim();
+      _part[0] = _name;
+      _part[1] = _value;
+      result.push(_part);
+    });
+    return result;
+  }
+}

package/src/testing/TestCliHelper.ts

@@ -4,6 +4,12 @@ export interface ITestRunCommandOptions {
 }
 
 export class TestCliHelper {
+  /**
+   * The globally set test timeout.
+   * @default 2000 The mocha default test timeout.
+   */
+  static testTimeout = 2000;
+
   static cleanTerminalOutput(s: string): string {
     let result = s.trim();
     result = result.replace(/[^\x20-\x7E\n]/gm, '');
@@ -37,9 +43,10 @@ export class TestCliHelper {
    * ```
    * 
    * @param fn The function to execute.
+   * @param timeout The test timeout. After this time the output is reset.
    * @returns The terminal output.
    */
-  static async grabOutput(fn: () => Promise<void>): Promise<string> {
+  static async grabOutput(fn: () => Promise<void>, timeout=TestCliHelper.testTimeout): Promise<string> {
     const messages: string[] = [];
     function noop(): void {
       //
@@ -64,11 +71,15 @@ export class TestCliHelper {
     process.stderr.write = messageHandler;
     console.clear = noop;
 
+    const handle = setTimeout(() => stop(), timeout);
+
     try {
       await fn();
       stop();
+      clearTimeout(handle);
     } catch (e) {
       stop();
+      clearTimeout(handle);
       throw e;
     }
     return messages.join('');