@difizen/libro-common 0.0.2-alpha.0

package/src/url.ts

@@ -0,0 +1,157 @@
+import { isWeb } from '@difizen/mana-common';
+import { posix } from 'path-browserify';
+import urlparse from 'url-parse';
+
+/**
+ * The namespace for URL-related functions.
+ */
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export class URL {
+  /**
+   * Parse URL and retrieve hostname
+   *
+   * @param url - The URL string to parse
+   *
+   * @returns a hostname string value
+   */
+  static getHostName(url: string): string {
+    return urlparse(url).hostname;
+  }
+  /**
+   * Normalize a url.
+   */
+  static normalize(url: string): string;
+  static normalize(url: undefined): undefined;
+  static normalize(url: string | undefined): string | undefined;
+  static normalize(url: string | undefined): string | undefined {
+    if (!url) {
+      return undefined;
+    }
+    if (isWeb) {
+      const a = document.createElement('a');
+      a.href = url;
+      return a.toString();
+    }
+    return urlparse(url).toString();
+  }
+
+  /**
+   * Join a sequence of url components and normalizes as in node `path.join`.
+   *
+   * @param parts - The url components.
+   *
+   * @returns the joined url.
+   */
+  static join(...parts: string[]): string {
+    let u = urlparse(parts[0], {});
+    // Schema-less URL can be only parsed as relative to a base URL
+    // see https://github.com/unshiftio/url-parse/issues/219#issuecomment-1002219326
+    const isSchemaLess = u.protocol === '' && u.slashes;
+    if (isSchemaLess) {
+      u = urlparse(parts[0], 'https:' + parts[0]);
+    }
+    const prefix = `${isSchemaLess ? '' : u.protocol}${u.slashes ? '//' : ''}${u.auth}${
+      u.auth ? '@' : ''
+    }${u.host}`;
+    // If there was a prefix, then the first path must start at the root.
+    const path = posix.join(
+      `${!!prefix && u.pathname[0] !== '/' ? '/' : ''}${u.pathname}`,
+      ...parts.slice(1),
+    );
+    return `${prefix}${path === '.' ? '' : path}`;
+  }
+
+  /**
+   * Encode the components of a multi-segment url.
+   *
+   * @param url - The url to encode.
+   *
+   * @returns the encoded url.
+   *
+   * #### Notes
+   * Preserves the `'/'` separators.
+   * Should not include the base url, since all parts are escaped.
+   */
+  static encodeParts(url: string): string {
+    return URL.join(...url.split('/').map(encodeURIComponent));
+  }
+  /**
+   * Parse a url into a URL object.
+   *
+   * @param urlString - The URL string to parse.
+   *
+   * @returns A URL object.
+   */
+  static parse(url: string): IUrl {
+    if (typeof document !== 'undefined' && document) {
+      const a = document.createElement('a');
+      a.href = url;
+      return a;
+    }
+    return urlparse(url);
+  }
+  /**
+   * Test whether the url is a local url.
+   *
+   * #### Notes
+   * This function returns `false` for any fully qualified url, including
+   * `data:`, `file:`, and `//` protocol URLs.
+   */
+  static isLocal(url: string): boolean {
+    const { protocol } = URL.parse(url);
+
+    return (
+      (!protocol || url.toLowerCase().indexOf(protocol) !== 0) && url.indexOf('/') !== 0
+    );
+  }
+}
+
+/**
+ * The interface for a URL object
+ */
+export interface IUrl {
+  /**
+   * The full URL string that was parsed with both the protocol and host
+   * components converted to lower-case.
+   */
+  href: string;
+
+  /**
+   * Identifies the URL's lower-cased protocol scheme.
+   */
+  protocol: string;
+
+  /**
+   * The full lower-cased host portion of the URL, including the port if
+   * specified.
+   */
+  host: string;
+
+  /**
+   * The lower-cased host name portion of the host component without the
+   * port included.
+   */
+  hostname: string;
+
+  /**
+   * The numeric port portion of the host component.
+   */
+  port: string;
+
+  /**
+   * The entire path section of the URL.
+   */
+  pathname: string;
+
+  /**
+   * The "fragment" portion of the URL including the leading ASCII hash
+   * `(#)` character
+   */
+  hash: string;
+
+  /**
+   * The search element, including leading question mark (`'?'`), if any,
+   * of the URL.
+   */
+  search?: string;
+}

package/src/utils.ts

@@ -0,0 +1,145 @@
+import type { PartialJSONObject, PartialJSONValue } from './json.js';
+import { isObject } from './json.js';
+import type {
+  ICell,
+  ICodeCell,
+  IMarkdownCell,
+  IRawCell,
+} from './protocol/cell-protocol.js';
+import type { MultilineString } from './protocol/notebook-protocol.js';
+import type {
+  IDisplayData,
+  IDisplayUpdate,
+  IError,
+  IExecuteResult,
+  IOutput,
+  IStream,
+} from './protocol/output-protocol.js';
+
+/**
+ * Validate a mime type/value pair.
+ *
+ * @param type - The mimetype name.
+ *
+ * @param value - The value associated with the type.
+ *
+ * @returns Whether the type/value pair are valid.
+ */
+export function validateMimeValue(
+  type: string,
+  value: MultilineString | PartialJSONObject,
+): boolean {
+  // Check if "application/json" or "application/foo+json"
+  const jsonTest = /^application\/.+\+json$/;
+  const isJSONType = type === 'application/json' || jsonTest.test(type);
+
+  const isString = (x: any) => {
+    return Object.prototype.toString.call(x) === '[object String]';
+  };
+
+  // If it is an array, make sure if is not a JSON type and it is an
+  // array of strings.
+  if (Array.isArray(value)) {
+    if (isJSONType) {
+      return false;
+    }
+    let valid = true;
+    value.forEach((v) => {
+      if (!isString(v)) {
+        valid = false;
+      }
+    });
+    return valid;
+  }
+
+  // If it is a string, make sure we are not a JSON type.
+  if (isString(value)) {
+    return !isJSONType;
+  }
+
+  // It is not a string, make sure it is a JSON type.
+  if (!isJSONType) {
+    return false;
+  }
+
+  // It is a JSON type, make sure it is a valid JSON object.
+  return isObject(value);
+}
+
+/**
+ * join multiline string, normalizing line endings to \n
+ * @param value
+ * @returns
+ */
+export function concatMultilineString(value: MultilineString): string {
+  if (Array.isArray(value)) {
+    return value.map((s) => s.replace(/\r\n/g, '\n').replace(/\r/g, '\n')).join('');
+  } else {
+    return value.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+  }
+}
+
+/**
+ * Test whether a cell is a raw cell.
+ */
+export function isRaw(cell: ICell): cell is IRawCell {
+  return cell.cell_type === 'raw';
+}
+
+/**
+ * Test whether a cell is a markdown cell.
+ */
+export function isMarkdown(cell: ICell): cell is IMarkdownCell {
+  return cell.cell_type === 'markdown';
+}
+
+/**
+ * Test whether a cell is a code cell.
+ */
+export function isCode(cell: ICell): cell is ICodeCell {
+  return cell.cell_type === 'code';
+}
+
+/**
+ * Test whether a cell is a code cell.
+ */
+export function isOutput(
+  output: PartialJSONValue | IOutput[] | undefined,
+): output is IOutput[] {
+  return !!(output && output instanceof Array);
+}
+
+/**
+ * Test whether an output is an execute result.
+ */
+export function isExecuteResult(output: IOutput): output is IExecuteResult {
+  return output.output_type === 'execute_result';
+}
+
+/**
+ * Test whether an output is from display data.
+ */
+export function isDisplayData(output: IOutput): output is IDisplayData {
+  return output.output_type === 'display_data';
+}
+
+/**
+ * Test whether an output is from updated display data.
+ */
+export function isDisplayUpdate(output: IOutput): output is IDisplayUpdate {
+  return output.output_type === 'update_display_data';
+}
+
+/**
+ * Test whether an output is from a stream.
+ */
+export function isStream(output: IOutput): output is IStream {
+  return output.output_type === 'stream';
+}
+
+/**
+ * Test whether an output is an error.
+ */
+export function isError(output: IOutput): output is IError {
+  return output.output_type === 'error';
+}