@difizen/libro-common 0.0.2-alpha.0

package/es/array.js

@@ -0,0 +1,577 @@
+/**
+ * Find the index of the first occurrence of a value in an array.
+ *
+ * @param array - The array-like object to search.
+ *
+ * @param value - The value to locate in the array. Values are
+ *   compared using strict `===` equality.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The index of the first occurrence of the value, or `-1`
+ *   if the value is not found.
+ *
+ * #### Notes
+ * If `stop < start` the search will wrap at the end of the array.
+ *
+ * #### Complexity
+ * Linear.
+ *
+ * #### Undefined Behavior
+ * A `start` or `stop` which is non-integral.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * let data = ['one', 'two', 'three', 'four', 'one'];
+ * firstIndexOfArray(data, 'red');        // -1
+ * firstIndexOfArray(data, 'one');        // 0
+ * firstIndexOfArray(data, 'one', 1);     // 4
+ * firstIndexOfArray(data, 'two', 2);     // -1
+ * firstIndexOfArray(data, 'two', 2, 1);  // 1
+ * ```
+ */
+export function firstIndexOfArray(array, value) {
+  var start = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var stop = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;
+  var n = array.length;
+  var arrStart = start;
+  var arrStop = stop;
+  if (n === 0) {
+    return -1;
+  }
+  if (arrStart < 0) {
+    arrStart = Math.max(0, arrStart + n);
+  } else {
+    arrStart = Math.min(arrStart, n - 1);
+  }
+  if (arrStop < 0) {
+    arrStop = Math.max(0, arrStop + n);
+  } else {
+    arrStop = Math.min(arrStop, n - 1);
+  }
+  var span;
+  if (arrStop < arrStart) {
+    span = arrStop + 1 + (n - arrStart);
+  } else {
+    span = arrStop - arrStart + 1;
+  }
+  for (var i = 0; i < span; ++i) {
+    var j = (arrStart + i) % n;
+    if (array[j] === value) {
+      return j;
+    }
+  }
+  return -1;
+}
+
+/**
+ * Find the index of the first value which matches a predicate.
+ *
+ * @param array - The array-like object to search.
+ *
+ * @param fn - The predicate function to apply to the values.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The index of the first matching value, or `-1` if no
+ *   matching value is found.
+ *
+ * #### Notes
+ * If `stop < start` the search will wrap at the end of the array.
+ *
+ * #### Complexity
+ * Linear.
+ *
+ * #### Undefined Behavior
+ * A `start` or `stop` which is non-integral.
+ *
+ * Modifying the length of the array while searching.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function isEven(value: number): boolean {
+ *   return value % 2 === 0;
+ * }
+ *
+ * let data = [1, 2, 3, 4, 3, 2, 1];
+ * findFirstArrayIndex(data, isEven);       // 1
+ * findFirstArrayIndex(data, isEven, 4);    // 5
+ * findFirstArrayIndex(data, isEven, 6);    // -1
+ * findFirstArrayIndex(data, isEven, 6, 5); // 1
+ * ```
+ */
+export function findFirstArrayIndex(array, fn) {
+  var start = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var stop = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;
+  var n = array.length;
+  var arrStart = start;
+  var arrStop = stop;
+  if (n === 0) {
+    return -1;
+  }
+  if (arrStart < 0) {
+    arrStart = Math.max(0, arrStart + n);
+  } else {
+    arrStart = Math.min(arrStart, n - 1);
+  }
+  if (arrStop < 0) {
+    arrStop = Math.max(0, arrStop + n);
+  } else {
+    arrStop = Math.min(arrStop, n - 1);
+  }
+  var span;
+  if (arrStop < arrStart) {
+    span = arrStop + 1 + (n - arrStart);
+  } else {
+    span = arrStop - arrStart + 1;
+  }
+  for (var i = 0; i < span; ++i) {
+    var j = (arrStart + i) % n;
+    if (fn(array[j], j)) {
+      return j;
+    }
+  }
+  return -1;
+}
+
+/**
+ * Find the index of the last value which matches a predicate.
+ *
+ * @param object - The array-like object to search.
+ *
+ * @param fn - The predicate function to apply to the values.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The index of the last matching value, or `-1` if no
+ *   matching value is found.
+ *
+ * #### Notes
+ * If `start < stop` the search will wrap at the front of the array.
+ *
+ * #### Complexity
+ * Linear.
+ *
+ * #### Undefined Behavior
+ * A `start` or `stop` which is non-integral.
+ *
+ * Modifying the length of the array while searching.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function isEven(value: number): boolean {
+ *   return value % 2 === 0;
+ * }
+ *
+ * let data = [1, 2, 3, 4, 3, 2, 1];
+ * findLastArrayIndex(data, isEven);        // 5
+ * findLastArrayIndex(data, isEven, 4);     // 3
+ * findLastArrayIndex(data, isEven, 0);     // -1
+ * findLastArrayIndex(data, isEven, 0, 1);  // 5
+ * ```
+ */
+export function findLastArrayIndex(array, fn) {
+  var start = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+  var stop = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  var arrStart = start;
+  var arrStop = stop;
+  var n = array.length;
+  if (n === 0) {
+    return -1;
+  }
+  if (arrStart < 0) {
+    arrStart = Math.max(0, arrStart + n);
+  } else {
+    arrStart = Math.min(arrStart, n - 1);
+  }
+  if (arrStop < 0) {
+    arrStop = Math.max(0, arrStop + n);
+  } else {
+    arrStop = Math.min(arrStop, n - 1);
+  }
+  var d;
+  if (arrStart < arrStop) {
+    d = arrStart + 1 + (n - arrStop);
+  } else {
+    d = arrStart - arrStop + 1;
+  }
+  for (var i = 0; i < d; ++i) {
+    var j = (arrStart - i + n) % n;
+    if (fn(array[j], j)) {
+      return j;
+    }
+  }
+  return -1;
+}
+
+/**
+ * Find the first value which matches a predicate.
+ *
+ * @param array - The array-like object to search.
+ *
+ * @param fn - The predicate function to apply to the values.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The first matching value, or `undefined` if no matching
+ *   value is found.
+ *
+ * #### Notes
+ * If `stop < start` the search will wrap at the end of the array.
+ *
+ * #### Complexity
+ * Linear.
+ *
+ * #### Undefined Behavior
+ * A `start` or `stop` which is non-integral.
+ *
+ * Modifying the length of the array while searching.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function isEven(value: number): boolean {
+ *   return value % 2 === 0;
+ * }
+ *
+ * let data = [1, 2, 3, 4, 3, 2, 1];
+ * findFirstArrayValue(data, isEven);       // 2
+ * findFirstArrayValue(data, isEven, 2);    // 4
+ * findFirstArrayValue(data, isEven, 6);    // undefined
+ * findFirstArrayValue(data, isEven, 6, 5); // 2
+ * ```
+ */
+export function findFirstArrayValue(array, fn) {
+  var start = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var stop = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;
+  var index = findFirstArrayIndex(array, fn, start, stop);
+  return index !== -1 ? array[index] : undefined;
+}
+
+/**
+ * Find the last value which matches a predicate.
+ *
+ * @param object - The array-like object to search.
+ *
+ * @param fn - The predicate function to apply to the values.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The last matching value, or `undefined` if no matching
+ *   value is found.
+ *
+ * #### Notes
+ * If `start < stop` the search will wrap at the front of the array.
+ *
+ * #### Complexity
+ * Linear.
+ *
+ * #### Undefined Behavior
+ * A `start` or `stop` which is non-integral.
+ *
+ * Modifying the length of the array while searching.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function isEven(value: number): boolean {
+ *   return value % 2 === 0;
+ * }
+ *
+ * let data = [1, 2, 3, 4, 3, 2, 1];
+ * findLastArrayValue(data, isEven);        // 2
+ * findLastArrayValue(data, isEven, 4);     // 4
+ * findLastArrayValue(data, isEven, 0);     // undefined
+ * findLastArrayValue(data, isEven, 0, 1);  // 2
+ * ```
+ */
+export function findLastArrayValue(array, fn) {
+  var start = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+  var stop = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  var index = findLastArrayIndex(array, fn, start, stop);
+  return index !== -1 ? array[index] : undefined;
+}
+
+/**
+ * Find the index of the first element which compares `>=` to a value.
+ *
+ * @param array - The sorted array-like object to search.
+ *
+ * @param value - The value to locate in the array.
+ *
+ * @param fn - The 3-way comparison function to apply to the values.
+ *   It should return `< 0` if an element is less than a value, `0` if
+ *   an element is equal to a value, or `> 0` if an element is greater
+ *   than a value.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The index of the first element which compares `>=` to the
+ *   value, or `length` if there is no such element. If the computed
+ *   index for `stop` is less than `start`, then the computed index
+ *   for `start` is returned.
+ *
+ * #### Notes
+ * The array must already be sorted in ascending order according to
+ * the comparison function.
+ *
+ * #### Complexity
+ * Logarithmic.
+ *
+ * #### Undefined Behavior
+ * Searching a range which is not sorted in ascending order.
+ *
+ * A `start` or `stop` which is non-integral.
+ *
+ * Modifying the length of the array while searching.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function numberCmp(a: number, b: number): number {
+ *   return a - b;
+ * }
+ *
+ * let data = [0, 3, 4, 7, 7, 9];
+ * lowerArrayBound(data, 0, numberCmp);   // 0
+ * lowerArrayBound(data, 6, numberCmp);   // 3
+ * lowerArrayBound(data, 7, numberCmp);   // 3
+ * lowerArrayBound(data, -1, numberCmp);  // 0
+ * lowerArrayBound(data, 10, numberCmp);  // 6
+ * ```
+ */
+export function lowerArrayBound(array, value, fn) {
+  var start = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  var stop = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : -1;
+  var arrStart = start;
+  var arrStop = stop;
+  var n = array.length;
+  if (n === 0) {
+    return 0;
+  }
+  if (arrStart < 0) {
+    arrStart = Math.max(0, arrStart + n);
+  } else {
+    arrStart = Math.min(arrStart, n - 1);
+  }
+  if (arrStop < 0) {
+    arrStop = Math.max(0, arrStop + n);
+  } else {
+    arrStop = Math.min(arrStop, n - 1);
+  }
+  var begin = arrStart;
+  var span = arrStop - arrStart + 1;
+  while (span > 0) {
+    var half = span >> 1;
+    var middle = begin + half;
+    if (fn(array[middle], value) < 0) {
+      begin = middle + 1;
+      span -= half + 1;
+    } else {
+      span = half;
+    }
+  }
+  return begin;
+}
+
+/**
+ * Find the index of the first element which compares `>` than a value.
+ *
+ * @param array - The sorted array-like object to search.
+ *
+ * @param value - The value to locate in the array.
+ *
+ * @param fn - The 3-way comparison function to apply to the values.
+ *   It should return `< 0` if an element is less than a value, `0` if
+ *   an element is equal to a value, or `> 0` if an element is greater
+ *   than a value.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The index of the first element which compares `>` than the
+ *   value, or `length` if there is no such element. If the computed
+ *   index for `stop` is less than `start`, then the computed index
+ *   for `start` is returned.
+ *
+ * #### Notes
+ * The array must already be sorted in ascending order according to
+ * the comparison function.
+ *
+ * #### Complexity
+ * Logarithmic.
+ *
+ * #### Undefined Behavior
+ * Searching a range which is not sorted in ascending order.
+ *
+ * A `start` or `stop` which is non-integral.
+ *
+ * Modifying the length of the array while searching.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function numberCmp(a: number, b: number): number {
+ *   return a - b;
+ * }
+ *
+ * let data = [0, 3, 4, 7, 7, 9];
+ * upperArrayBound(data, 0, numberCmp);   // 1
+ * upperArrayBound(data, 6, numberCmp);   // 3
+ * upperArrayBound(data, 7, numberCmp);   // 5
+ * upperArrayBound(data, -1, numberCmp);  // 0
+ * upperArrayBound(data, 10, numberCmp);  // 6
+ * ```
+ */
+export function upperArrayBound(array, value, fn) {
+  var start = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  var stop = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : -1;
+  var n = array.length;
+  var arrStart = start;
+  var arrStop = stop;
+  if (n === 0) {
+    return 0;
+  }
+  if (arrStart < 0) {
+    arrStart = Math.max(0, arrStart + n);
+  } else {
+    arrStart = Math.min(arrStart, n - 1);
+  }
+  if (arrStop < 0) {
+    arrStop = Math.max(0, arrStop + n);
+  } else {
+    arrStop = Math.min(arrStop, n - 1);
+  }
+  var begin = arrStart;
+  var span = arrStop - arrStart + 1;
+  while (span > 0) {
+    var half = span >> 1;
+    var middle = begin + half;
+    if (fn(array[middle], value) > 0) {
+      span = half;
+    } else {
+      begin = middle + 1;
+      span -= half + 1;
+    }
+  }
+  return begin;
+}
+
+/**
+ * Remove all occurrences of values which match a predicate.
+ *
+ * @param array - The array of interest.
+ *
+ * @param fn - The predicate function to apply to the values.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The number of elements removed from the array.
+ *
+ * #### Notes
+ * If `stop < start` the search will conceptually wrap at the end of
+ * the array, however the array will be traversed front-to-back.
+ *
+ * #### Complexity
+ * Linear.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function isEven(value: number): boolean {
+ *   return value % 2 === 0;
+ * }
+ *
+ * function isNegative(value: number): boolean {
+ *   return value < 0;
+ * }
+ *
+ * let data = [0, 12, -13, -9, 23, 39, 14, -15, 12, 75];
+ * removeAllWhereFromArray(data, isEven);            // 4
+ * removeAllWhereFromArray(data, isNegative, 0, 3);  // 2
+ * ```
+ */
+export function removeAllWhereFromArray(array, fn) {
+  var start = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var stop = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;
+  var n = array.length;
+  var arrStart = start;
+  var arrStop = stop;
+  if (n === 0) {
+    return 0;
+  }
+  if (arrStart < 0) {
+    arrStart = Math.max(0, arrStart + n);
+  } else {
+    arrStart = Math.min(arrStart, n - 1);
+  }
+  if (arrStop < 0) {
+    arrStop = Math.max(0, arrStop + n);
+  } else {
+    arrStop = Math.min(arrStop, n - 1);
+  }
+  var count = 0;
+  for (var i = 0; i < n; ++i) {
+    if (arrStart <= arrStop && i >= arrStart && i <= arrStop && fn(array[i], i)) {
+      count++;
+    } else if (arrStop < arrStart && (i <= arrStop || i >= arrStart) && fn(array[i], i)) {
+      count++;
+    } else if (count > 0) {
+      array[i - count] = array[i];
+    }
+  }
+  if (count > 0) {
+    array.length = n - count;
+  }
+  return count;
+}

package/es/display-wrapper.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export declare const DisplayWrapComponent: React.FC<{
+    children: any;
+    mode: boolean | undefined;
+}>;
+//# sourceMappingURL=display-wrapper.d.ts.map

package/es/display-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"display-wrapper.d.ts","sourceRoot":"","sources":["../src/display-wrapper.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC;IAC1C,QAAQ,EAAE,GAAG,CAAC;IACd,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC;CAC3B,CAKA,CAAC"}

package/es/display-wrapper.js

@@ -0,0 +1,12 @@
+import React from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
+export var DisplayWrapComponent = function DisplayWrapComponent(_ref) {
+  var children = _ref.children,
+    mode = _ref.mode;
+  if (mode) {
+    return null;
+  }
+  return /*#__PURE__*/_jsx("div", {
+    children: children
+  });
+};

package/es/index.d.ts

@@ -0,0 +1,11 @@
+export * from './array.js';
+export * from './iter.js';
+export * from './json.js';
+export * from './utils.js';
+export * from './sanitizer.js';
+export * from './url.js';
+export * from './path.js';
+export * from './polling/index.js';
+export * from './display-wrapper.js';
+export * from './protocol/index.js';
+//# sourceMappingURL=index.d.ts.map

package/es/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC"}

package/es/index.js

@@ -0,0 +1,10 @@
+export * from "./array.js";
+export * from "./iter.js";
+export * from "./json.js";
+export * from "./utils.js";
+export * from "./sanitizer.js";
+export * from "./url.js";
+export * from "./path.js";
+export * from "./polling/index.js";
+export * from "./display-wrapper.js";
+export * from "./protocol/index.js";