@hocuspocus/common 2.8.0 → 2.9.0-rc.0

package/dist/hocuspocus-common.esm.js

@@ -1,25 +1,38 @@
 /**
- * @param {string} s
- * @return {string}
+ * Common Math expressions.
+ *
+ * @module math
  */
-const toLowerCase = s => s.toLowerCase();
 
-const trimLeftRegex = /^\s*/g;
+const floor = Math.floor;
 
 /**
- * @param {string} s
- * @return {string}
+ * @function
+ * @param {number} a
+ * @param {number} b
+ * @return {number} The smaller element of a and b
+ */
+const min = (a, b) => a < b ? a : b;
+
+/**
+ * @function
+ * @param {number} a
+ * @param {number} b
+ * @return {number} The bigger element of a and b
  */
-const trimLeft = s => s.replace(trimLeftRegex, '');
+const max = (a, b) => a > b ? a : b;
 
-const fromCamelCaseRegex = /([A-Z])/g;
+/* eslint-env browser */
+const BIT8 = 128;
+const BITS7 = 127;
 
 /**
- * @param {string} s
- * @param {string} separator
- * @return {string}
+ * Utility helpers for working with numbers.
+ *
+ * @module number
  */
-const fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, match => `${separator}${toLowerCase(match)}`));
+
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
 
 /**
  * @param {string} str
@@ -66,244 +79,155 @@ if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
 }
 
 /**
- * Utility module to work with key-value stores.
- *
- * @module map
- */
-
-/**
- * Creates a new Map instance.
+ * Efficient schema-less binary encoding with support for variable length encoding.
  *
- * @function
- * @return {Map<any, any>}
+ * Use [lib0/encoding] with [lib0/decoding]. Every encoding function has a corresponding decoding function.
  *
- * @function
- */
-const create$1 = () => new Map();
-
-/**
- * Often used conditions.
+ * Encodes numbers in little-endian order (least to most significant byte order)
+ * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
+ * which is also used in Protocol Buffers.
  *
- * @module conditions
- */
-
-/**
- * @template T
- * @param {T|null|undefined} v
- * @return {T|null}
- */
-/* c8 ignore next */
-const undefinedToNull = v => v === undefined ? null : v;
-
-/* eslint-env browser */
-
-/**
- * Isomorphic variable storage.
+ * ```js
+ * // encoding step
+ * const encoder = encoding.createEncoder()
+ * encoding.writeVarUint(encoder, 256)
+ * encoding.writeVarString(encoder, 'Hello world!')
+ * const buf = encoding.toUint8Array(encoder)
+ * ```
  *
- * Uses LocalStorage in the browser and falls back to in-memory storage.
+ * ```js
+ * // decoding step
+ * const decoder = decoding.createDecoder(buf)
+ * decoding.readVarUint(decoder) // => 256
+ * decoding.readVarString(decoder) // => 'Hello world!'
+ * decoding.hasContent(decoder) // => false - all data is read
+ * ```
  *
- * @module storage
+ * @module encoding
  */
 
-/* c8 ignore start */
-class VarStoragePolyfill {
-  constructor () {
-    this.map = new Map();
-  }
-
-  /**
-   * @param {string} key
-   * @param {any} newValue
-   */
-  setItem (key, newValue) {
-    this.map.set(key, newValue);
-  }
-
-  /**
-   * @param {string} key
-   */
-  getItem (key) {
-    return this.map.get(key)
-  }
-}
-/* c8 ignore stop */
-
 /**
- * @type {any}
+ * Write one byte to the encoder.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {number} num The byte that is to be encoded.
  */
-let _localStorage = new VarStoragePolyfill();
-let usePolyfill = true;
-
-/* c8 ignore start */
-try {
-  // if the same-origin rule is violated, accessing localStorage might thrown an error
-  if (typeof localStorage !== 'undefined') {
-    _localStorage = localStorage;
-    usePolyfill = false;
+const write = (encoder, num) => {
+  const bufferLen = encoder.cbuf.length;
+  if (encoder.cpos === bufferLen) {
+    encoder.bufs.push(encoder.cbuf);
+    encoder.cbuf = new Uint8Array(bufferLen * 2);
+    encoder.cpos = 0;
   }
-} catch (e) { }
-/* c8 ignore stop */
-
-/**
- * This is basically localStorage in browser, or a polyfill in nodejs
- */
-/* c8 ignore next */
-const varStorage = _localStorage;
+  encoder.cbuf[encoder.cpos++] = num;
+};
 
 /**
- * Common functions and function call helpers.
+ * Write a variable length unsigned integer. Max encodable integer is 2^53.
  *
- * @module function
+ * @function
+ * @param {Encoder} encoder
+ * @param {number} num The number that is to be encoded.
  */
+const writeVarUint = (encoder, num) => {
+  while (num > BITS7) {
+    write(encoder, BIT8 | (BITS7 & num));
+    num = floor(num / 128); // shift >>> 7
+  }
+  write(encoder, BITS7 & num);
+};
 
 /**
- * @template V
- * @template {V} OPTS
- *
- * @param {V} value
- * @param {Array<OPTS>} options
+ * A cache to store strings temporarily
  */
-// @ts-ignore
-const isOneOf = (value, options) => options.includes(value);
+const _strBuffer = new Uint8Array(30000);
+const _maxStrBSize = _strBuffer.length / 3;
 
 /**
- * Isomorphic module to work access the environment (query params, env variables).
+ * Write a variable length string.
  *
- * @module map
- */
-
-/* c8 ignore next */
-// @ts-ignore
-const isNode = typeof process !== 'undefined' && process.release &&
-  /node|io\.js/.test(process.release.name);
-/* c8 ignore next 3 */
-typeof navigator !== 'undefined'
-  ? /Mac/.test(navigator.platform)
-  : false;
-
-/**
- * @type {Map<string,string>}
+ * @function
+ * @param {Encoder} encoder
+ * @param {String} str The string that is to be encoded.
  */
-let params;
-
-/* c8 ignore start */
-const computeParams = () => {
-  if (params === undefined) {
-    if (isNode) {
-      params = create$1();
-      const pargs = process.argv;
-      let currParamName = null;
-      for (let i = 0; i < pargs.length; i++) {
-        const parg = pargs[i];
-        if (parg[0] === '-') {
-          if (currParamName !== null) {
-            params.set(currParamName, '');
-          }
-          currParamName = parg;
-        } else {
-          if (currParamName !== null) {
-            params.set(currParamName, parg);
-            currParamName = null;
-          }
-        }
-      }
-      if (currParamName !== null) {
-        params.set(currParamName, '');
-      }
-      // in ReactNative for example this would not be true (unless connected to the Remote Debugger)
-    } else if (typeof location === 'object') {
-      params = create$1(); // eslint-disable-next-line no-undef
-      (location.search || '?').slice(1).split('&').forEach((kv) => {
-        if (kv.length !== 0) {
-          const [key, value] = kv.split('=');
-          params.set(`--${fromCamelCase(key, '-')}`, value);
-          params.set(`-${fromCamelCase(key, '-')}`, value);
-        }
-      });
-    } else {
-      params = create$1();
+const _writeVarStringNative = (encoder, str) => {
+  if (str.length < _maxStrBSize) {
+    // We can encode the string into the existing buffer
+    /* c8 ignore next */
+    const written = utf8TextEncoder.encodeInto(str, _strBuffer).written || 0;
+    writeVarUint(encoder, written);
+    for (let i = 0; i < written; i++) {
+      write(encoder, _strBuffer[i]);
     }
+  } else {
+    writeVarUint8Array(encoder, encodeUtf8(str));
   }
-  return params
 };
-/* c8 ignore stop */
 
 /**
- * @param {string} name
- * @return {boolean}
- */
-/* c8 ignore next */
-const hasParam = (name) => computeParams().has(name);
-
-/**
- * @param {string} name
- * @return {string|null}
- */
-/* c8 ignore next 4 */
-const getVariable = (name) =>
-  isNode
-    ? undefinedToNull(process.env[name.toUpperCase()])
-    : undefinedToNull(varStorage.getItem(name));
-
-/**
- * @param {string} name
- * @return {boolean}
- */
-/* c8 ignore next 2 */
-const hasConf = (name) =>
-  hasParam('--' + name) || getVariable(name) !== null;
-
-/* c8 ignore next */
-hasConf('production');
-
-/* c8 ignore next 2 */
-const forceColor = isNode &&
-  isOneOf(process.env.FORCE_COLOR, ['true', '1', '2']);
-
-/* c8 ignore start */
-!hasParam('no-colors') &&
-  (!isNode || process.stdout.isTTY || forceColor) && (
-  !isNode || hasParam('color') || forceColor ||
-    getVariable('COLORTERM') !== null ||
-    (getVariable('TERM') || '').includes('color')
-);
-/* c8 ignore stop */
-
-/* eslint-env browser */
-const BIT8 = 128;
-const BITS7 = 127;
-
-/**
- * Common Math expressions.
+ * Write a variable length string.
  *
- * @module math
+ * @function
+ * @param {Encoder} encoder
+ * @param {String} str The string that is to be encoded.
  */
-
-const floor = Math.floor;
+const _writeVarStringPolyfill = (encoder, str) => {
+  const encodedString = unescape(encodeURIComponent(str));
+  const len = encodedString.length;
+  writeVarUint(encoder, len);
+  for (let i = 0; i < len; i++) {
+    write(encoder, /** @type {number} */ (encodedString.codePointAt(i)));
+  }
+};
 
 /**
+ * Write a variable length string.
+ *
  * @function
- * @param {number} a
- * @param {number} b
- * @return {number} The smaller element of a and b
+ * @param {Encoder} encoder
+ * @param {String} str The string that is to be encoded.
  */
-const min = (a, b) => a < b ? a : b;
+/* c8 ignore next */
+const writeVarString = (utf8TextEncoder && /** @type {any} */ (utf8TextEncoder).encodeInto) ? _writeVarStringNative : _writeVarStringPolyfill;
 
 /**
+ * Append fixed-length Uint8Array to the encoder.
+ *
  * @function
- * @param {number} a
- * @param {number} b
- * @return {number} The bigger element of a and b
+ * @param {Encoder} encoder
+ * @param {Uint8Array} uint8Array
  */
-const max = (a, b) => a > b ? a : b;
+const writeUint8Array = (encoder, uint8Array) => {
+  const bufferLen = encoder.cbuf.length;
+  const cpos = encoder.cpos;
+  const leftCopyLen = min(bufferLen - cpos, uint8Array.length);
+  const rightCopyLen = uint8Array.length - leftCopyLen;
+  encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos);
+  encoder.cpos += leftCopyLen;
+  if (rightCopyLen > 0) {
+    // Still something to write, write right half..
+    // Append new buffer
+    encoder.bufs.push(encoder.cbuf);
+    // must have at least size of remaining buffer
+    encoder.cbuf = new Uint8Array(max(bufferLen * 2, rightCopyLen));
+    // copy array
+    encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
+    encoder.cpos = rightCopyLen;
+  }
+};
 
 /**
- * Utility helpers for working with numbers.
+ * Append an Uint8Array to Encoder.
  *
- * @module number
+ * @function
+ * @param {Encoder} encoder
+ * @param {Uint8Array} uint8Array
  */
-
-const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+const writeVarUint8Array = (encoder, uint8Array) => {
+  writeVarUint(encoder, uint8Array.byteLength);
+  writeUint8Array(encoder, uint8Array);
+};
 
 /**
  * Error helpers.
@@ -361,7 +285,7 @@ const errorIntegerOutOfRange = create('Integer out of Range');
  * @return {Uint8Array}
  */
 const readUint8Array = (decoder, len) => {
-  const view = createUint8ArrayViewFromArrayBuffer(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
+  const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
   decoder.pos += len;
   return view
 };
@@ -477,172 +401,6 @@ const _readVarStringNative = decoder =>
 /* c8 ignore next */
 const readVarString = utf8TextDecoder ? _readVarStringNative : _readVarStringPolyfill;
 
-/**
- * Utility functions to work with buffers (Uint8Array).
- *
- * @module buffer
- */
-
-/**
- * Create Uint8Array with initial content from buffer
- *
- * @param {ArrayBuffer} buffer
- * @param {number} byteOffset
- * @param {number} length
- */
-const createUint8ArrayViewFromArrayBuffer = (buffer, byteOffset, length) => new Uint8Array(buffer, byteOffset, length);
-
-/**
- * Efficient schema-less binary encoding with support for variable length encoding.
- *
- * Use [lib0/encoding] with [lib0/decoding]. Every encoding function has a corresponding decoding function.
- *
- * Encodes numbers in little-endian order (least to most significant byte order)
- * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
- * which is also used in Protocol Buffers.
- *
- * ```js
- * // encoding step
- * const encoder = encoding.createEncoder()
- * encoding.writeVarUint(encoder, 256)
- * encoding.writeVarString(encoder, 'Hello world!')
- * const buf = encoding.toUint8Array(encoder)
- * ```
- *
- * ```js
- * // decoding step
- * const decoder = decoding.createDecoder(buf)
- * decoding.readVarUint(decoder) // => 256
- * decoding.readVarString(decoder) // => 'Hello world!'
- * decoding.hasContent(decoder) // => false - all data is read
- * ```
- *
- * @module encoding
- */
-
-/**
- * Write one byte to the encoder.
- *
- * @function
- * @param {Encoder} encoder
- * @param {number} num The byte that is to be encoded.
- */
-const write = (encoder, num) => {
-  const bufferLen = encoder.cbuf.length;
-  if (encoder.cpos === bufferLen) {
-    encoder.bufs.push(encoder.cbuf);
-    encoder.cbuf = new Uint8Array(bufferLen * 2);
-    encoder.cpos = 0;
-  }
-  encoder.cbuf[encoder.cpos++] = num;
-};
-
-/**
- * Write a variable length unsigned integer. Max encodable integer is 2^53.
- *
- * @function
- * @param {Encoder} encoder
- * @param {number} num The number that is to be encoded.
- */
-const writeVarUint = (encoder, num) => {
-  while (num > BITS7) {
-    write(encoder, BIT8 | (BITS7 & num));
-    num = floor(num / 128); // shift >>> 7
-  }
-  write(encoder, BITS7 & num);
-};
-
-/**
- * A cache to store strings temporarily
- */
-const _strBuffer = new Uint8Array(30000);
-const _maxStrBSize = _strBuffer.length / 3;
-
-/**
- * Write a variable length string.
- *
- * @function
- * @param {Encoder} encoder
- * @param {String} str The string that is to be encoded.
- */
-const _writeVarStringNative = (encoder, str) => {
-  if (str.length < _maxStrBSize) {
-    // We can encode the string into the existing buffer
-    /* c8 ignore next */
-    const written = utf8TextEncoder.encodeInto(str, _strBuffer).written || 0;
-    writeVarUint(encoder, written);
-    for (let i = 0; i < written; i++) {
-      write(encoder, _strBuffer[i]);
-    }
-  } else {
-    writeVarUint8Array(encoder, encodeUtf8(str));
-  }
-};
-
-/**
- * Write a variable length string.
- *
- * @function
- * @param {Encoder} encoder
- * @param {String} str The string that is to be encoded.
- */
-const _writeVarStringPolyfill = (encoder, str) => {
-  const encodedString = unescape(encodeURIComponent(str));
-  const len = encodedString.length;
-  writeVarUint(encoder, len);
-  for (let i = 0; i < len; i++) {
-    write(encoder, /** @type {number} */ (encodedString.codePointAt(i)));
-  }
-};
-
-/**
- * Write a variable length string.
- *
- * @function
- * @param {Encoder} encoder
- * @param {String} str The string that is to be encoded.
- */
-/* c8 ignore next */
-const writeVarString = (utf8TextEncoder && /** @type {any} */ (utf8TextEncoder).encodeInto) ? _writeVarStringNative : _writeVarStringPolyfill;
-
-/**
- * Append fixed-length Uint8Array to the encoder.
- *
- * @function
- * @param {Encoder} encoder
- * @param {Uint8Array} uint8Array
- */
-const writeUint8Array = (encoder, uint8Array) => {
-  const bufferLen = encoder.cbuf.length;
-  const cpos = encoder.cpos;
-  const leftCopyLen = min(bufferLen - cpos, uint8Array.length);
-  const rightCopyLen = uint8Array.length - leftCopyLen;
-  encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos);
-  encoder.cpos += leftCopyLen;
-  if (rightCopyLen > 0) {
-    // Still something to write, write right half..
-    // Append new buffer
-    encoder.bufs.push(encoder.cbuf);
-    // must have at least size of remaining buffer
-    encoder.cbuf = new Uint8Array(max(bufferLen * 2, rightCopyLen));
-    // copy array
-    encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
-    encoder.cpos = rightCopyLen;
-  }
-};
-
-/**
- * Append an Uint8Array to Encoder.
- *
- * @function
- * @param {Encoder} encoder
- * @param {Uint8Array} uint8Array
- */
-const writeVarUint8Array = (encoder, uint8Array) => {
-  writeVarUint(encoder, uint8Array.byteLength);
-  writeUint8Array(encoder, uint8Array);
-};
-
 var AuthMessageType;
 (function (AuthMessageType) {
     AuthMessageType[AuthMessageType["Token"] = 0] = "Token";