brilliantsole 0.0.1

package/src/utils/cbor.js

@@ -0,0 +1,429 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014-2016 Patrick Gansterer <paroga@paroga.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+const POW_2_24 = 5.960464477539063e-8;
+const POW_2_32 = 4294967296;
+const POW_2_53 = 9007199254740992;
+
+export function encode(value) {
+  let data = new ArrayBuffer(256);
+  let dataView = new DataView(data);
+  let lastLength;
+  let offset = 0;
+
+  function prepareWrite(length) {
+    let newByteLength = data.byteLength;
+    const requiredLength = offset + length;
+    while (newByteLength < requiredLength) {
+      newByteLength <<= 1;
+    }
+    if (newByteLength !== data.byteLength) {
+      const oldDataView = dataView;
+      data = new ArrayBuffer(newByteLength);
+      dataView = new DataView(data);
+      const uint32count = (offset + 3) >> 2;
+      for (let i = 0; i < uint32count; ++i) {
+        dataView.setUint32(i << 2, oldDataView.getUint32(i << 2));
+      }
+    }
+
+    lastLength = length;
+    return dataView;
+  }
+  function commitWrite() {
+    offset += lastLength;
+  }
+  function writeFloat64(value) {
+    commitWrite(prepareWrite(8).setFloat64(offset, value));
+  }
+  function writeUint8(value) {
+    commitWrite(prepareWrite(1).setUint8(offset, value));
+  }
+  function writeUint8Array(value) {
+    const dataView = prepareWrite(value.length);
+    for (let i = 0; i < value.length; ++i) {
+      dataView.setUint8(offset + i, value[i]);
+    }
+    commitWrite();
+  }
+  function writeUint16(value) {
+    commitWrite(prepareWrite(2).setUint16(offset, value));
+  }
+  function writeUint32(value) {
+    commitWrite(prepareWrite(4).setUint32(offset, value));
+  }
+  function writeUint64(value) {
+    const low = value % POW_2_32;
+    const high = (value - low) / POW_2_32;
+    const dataView = prepareWrite(8);
+    dataView.setUint32(offset, high);
+    dataView.setUint32(offset + 4, low);
+    commitWrite();
+  }
+  function writeTypeAndLength(type, length) {
+    if (length < 24) {
+      writeUint8((type << 5) | length);
+    } else if (length < 0x100) {
+      writeUint8((type << 5) | 24);
+      writeUint8(length);
+    } else if (length < 0x10000) {
+      writeUint8((type << 5) | 25);
+      writeUint16(length);
+    } else if (length < 0x100000000) {
+      writeUint8((type << 5) | 26);
+      writeUint32(length);
+    } else {
+      writeUint8((type << 5) | 27);
+      writeUint64(length);
+    }
+  }
+
+  function encodeItem(value) {
+    let i;
+    const utf8data = [];
+    let length;
+
+    if (value === false) {
+      return writeUint8(0xf4);
+    }
+    if (value === true) {
+      return writeUint8(0xf5);
+    }
+    if (value === null) {
+      return writeUint8(0xf6);
+    }
+    if (value === undefined) {
+      return writeUint8(0xf7);
+    }
+
+    switch (typeof value) {
+      case "number":
+        if (Math.floor(value) === value) {
+          if (value >= 0 && value <= POW_2_53) {
+            return writeTypeAndLength(0, value);
+          }
+          if (-POW_2_53 <= value && value < 0) {
+            return writeTypeAndLength(1, -(value + 1));
+          }
+        }
+        writeUint8(0xfb);
+        return writeFloat64(value);
+
+      case "string":
+        for (i = 0; i < value.length; ++i) {
+          let charCode = value.charCodeAt(i);
+          if (charCode < 0x80) {
+            utf8data.push(charCode);
+          } else if (charCode < 0x800) {
+            utf8data.push(0xc0 | (charCode >> 6));
+            utf8data.push(0x80 | (charCode & 0x3f));
+          } else if (charCode < 0xd800) {
+            utf8data.push(0xe0 | (charCode >> 12));
+            utf8data.push(0x80 | ((charCode >> 6) & 0x3f));
+            utf8data.push(0x80 | (charCode & 0x3f));
+          } else {
+            charCode = (charCode & 0x3ff) << 10;
+            charCode |= value.charCodeAt(++i) & 0x3ff;
+            charCode += 0x10000;
+
+            utf8data.push(0xf0 | (charCode >> 18));
+            utf8data.push(0x80 | ((charCode >> 12) & 0x3f));
+            utf8data.push(0x80 | ((charCode >> 6) & 0x3f));
+            utf8data.push(0x80 | (charCode & 0x3f));
+          }
+        }
+
+        writeTypeAndLength(3, utf8data.length);
+        return writeUint8Array(utf8data);
+
+      default:
+        if (Array.isArray(value)) {
+          length = value.length;
+          writeTypeAndLength(4, length);
+          for (i = 0; i < length; ++i) {
+            encodeItem(value[i]);
+          }
+        } else if (value instanceof Uint8Array) {
+          writeTypeAndLength(2, value.length);
+          writeUint8Array(value);
+        } else {
+          const keys = Object.keys(value);
+          length = keys.length;
+          writeTypeAndLength(5, length);
+          for (i = 0; i < length; ++i) {
+            const key = keys[i];
+            encodeItem(key);
+            encodeItem(value[key]);
+          }
+        }
+    }
+  }
+
+  encodeItem(value);
+
+  if ("slice" in data) {
+    return data.slice(0, offset);
+  }
+
+  const ret = new ArrayBuffer(offset);
+  const retView = new DataView(ret);
+  for (let i = 0; i < offset; ++i) {
+    retView.setUint8(i, dataView.getUint8(i));
+  }
+  return ret;
+}
+
+export function decode(data, tagger, simpleValue) {
+  const dataView = new DataView(data);
+  let offset = 0;
+
+  if (typeof tagger !== "function") {
+    tagger = function (value) {
+      return value;
+    };
+  }
+  if (typeof simpleValue !== "function") {
+    simpleValue = function () {
+      return undefined;
+    };
+  }
+
+  function commitRead(length, value) {
+    offset += length;
+    return value;
+  }
+  function readArrayBuffer(length) {
+    return commitRead(length, new Uint8Array(data, offset, length));
+  }
+  function readFloat16() {
+    const tempArrayBuffer = new ArrayBuffer(4);
+    const tempDataView = new DataView(tempArrayBuffer);
+    const value = readUint16();
+
+    const sign = value & 0x8000;
+    let exponent = value & 0x7c00;
+    const fraction = value & 0x03ff;
+
+    if (exponent === 0x7c00) {
+      exponent = 0xff << 10;
+    } else if (exponent !== 0) {
+      exponent += (127 - 15) << 10;
+    } else if (fraction !== 0) {
+      return (sign ? -1 : 1) * fraction * POW_2_24;
+    }
+
+    tempDataView.setUint32(0, (sign << 16) | (exponent << 13) | (fraction << 13));
+    return tempDataView.getFloat32(0);
+  }
+  function readFloat32() {
+    return commitRead(4, dataView.getFloat32(offset));
+  }
+  function readFloat64() {
+    return commitRead(8, dataView.getFloat64(offset));
+  }
+  function readUint8() {
+    return commitRead(1, dataView.getUint8(offset));
+  }
+  function readUint16() {
+    return commitRead(2, dataView.getUint16(offset));
+  }
+  function readUint32() {
+    return commitRead(4, dataView.getUint32(offset));
+  }
+  function readUint64() {
+    return readUint32() * POW_2_32 + readUint32();
+  }
+  function readBreak() {
+    if (dataView.getUint8(offset) !== 0xff) {
+      return false;
+    }
+    offset += 1;
+    return true;
+  }
+  function readLength(additionalInformation) {
+    if (additionalInformation < 24) {
+      return additionalInformation;
+    }
+    if (additionalInformation === 24) {
+      return readUint8();
+    }
+    if (additionalInformation === 25) {
+      return readUint16();
+    }
+    if (additionalInformation === 26) {
+      return readUint32();
+    }
+    if (additionalInformation === 27) {
+      return readUint64();
+    }
+    if (additionalInformation === 31) {
+      return -1;
+    }
+    throw new Error("Invalid length encoding");
+  }
+  function readIndefiniteStringLength(majorType) {
+    const initialByte = readUint8();
+    if (initialByte === 0xff) {
+      return -1;
+    }
+    const length = readLength(initialByte & 0x1f);
+    if (length < 0 || initialByte >> 5 !== majorType) {
+      throw new Error("Invalid indefinite length element");
+    }
+    return length;
+  }
+
+  function appendUtf16Data(utf16data, length) {
+    for (let i = 0; i < length; ++i) {
+      let value = readUint8();
+      if (value & 0x80) {
+        if (value < 0xe0) {
+          value = ((value & 0x1f) << 6) | (readUint8() & 0x3f);
+          length -= 1;
+        } else if (value < 0xf0) {
+          value = ((value & 0x0f) << 12) | ((readUint8() & 0x3f) << 6) | (readUint8() & 0x3f);
+          length -= 2;
+        } else {
+          value =
+            ((value & 0x0f) << 18) | ((readUint8() & 0x3f) << 12) | ((readUint8() & 0x3f) << 6) | (readUint8() & 0x3f);
+          length -= 3;
+        }
+      }
+
+      if (value < 0x10000) {
+        utf16data.push(value);
+      } else {
+        value -= 0x10000;
+        utf16data.push(0xd800 | (value >> 10));
+        utf16data.push(0xdc00 | (value & 0x3ff));
+      }
+    }
+  }
+
+  function decodeItem() {
+    const initialByte = readUint8();
+    const majorType = initialByte >> 5;
+    const additionalInformation = initialByte & 0x1f;
+    let i;
+    let length;
+
+    if (majorType === 7) {
+      switch (additionalInformation) {
+        case 25:
+          return readFloat16();
+        case 26:
+          return readFloat32();
+        case 27:
+          return readFloat64();
+      }
+    }
+
+    length = readLength(additionalInformation);
+    if (length < 0 && (majorType < 2 || majorType > 6)) {
+      throw new Error("Invalid length");
+    }
+
+    const utf16data = [];
+    let retArray;
+    const retObject = {};
+
+    switch (majorType) {
+      case 0:
+        return length;
+      case 1:
+        return -1 - length;
+      case 2:
+        if (length < 0) {
+          const elements = [];
+          let fullArrayLength = 0;
+          while ((length = readIndefiniteStringLength(majorType)) >= 0) {
+            fullArrayLength += length;
+            elements.push(readArrayBuffer(length));
+          }
+          const fullArray = new Uint8Array(fullArrayLength);
+          let fullArrayOffset = 0;
+          for (i = 0; i < elements.length; ++i) {
+            fullArray.set(elements[i], fullArrayOffset);
+            fullArrayOffset += elements[i].length;
+          }
+          return fullArray;
+        }
+        return readArrayBuffer(length);
+      case 3:
+        if (length < 0) {
+          while ((length = readIndefiniteStringLength(majorType)) >= 0) {
+            appendUtf16Data(utf16data, length);
+          }
+        } else {
+          appendUtf16Data(utf16data, length);
+        }
+        return String.fromCharCode.apply(null, utf16data);
+      case 4:
+        if (length < 0) {
+          retArray = [];
+          while (!readBreak()) {
+            retArray.push(decodeItem());
+          }
+        } else {
+          retArray = new Array(length);
+          for (i = 0; i < length; ++i) {
+            retArray[i] = decodeItem();
+          }
+        }
+        return retArray;
+      case 5:
+        for (i = 0; i < length || (length < 0 && !readBreak()); ++i) {
+          const key = decodeItem();
+          retObject[key] = decodeItem();
+        }
+        return retObject;
+      case 6:
+        return tagger(decodeItem(), length);
+      case 7:
+        switch (length) {
+          case 20:
+            return false;
+          case 21:
+            return true;
+          case 22:
+            return null;
+          case 23:
+            return undefined;
+          default:
+            return simpleValue(length);
+        }
+    }
+  }
+
+  const ret = decodeItem();
+  if (offset !== data.byteLength) {
+    throw new Error("Remaining bytes");
+  }
+  return ret;
+}
+
+export const CBOR = {
+  encode,
+  decode,
+};

package/src/utils/checksum.ts

@@ -0,0 +1,41 @@
+import { createConsole } from "./Console.ts";
+
+const _console = createConsole("checksum", { log: true });
+
+// https://github.com/googlecreativelab/tiny-motion-trainer/blob/5fceb49f018ae0c403bf9f0ccc437309c2acb507/frontend/src/tf4micro-motion-kit/modules/bleFileTransfer#L195
+
+// See http://home.thep.lu.se/~bjorn/crc/ for more information on simple CRC32 calculations.
+export function crc32ForByte(r: number) {
+  for (let j = 0; j < 8; ++j) {
+    r = (r & 1 ? 0 : 0xedb88320) ^ (r >>> 1);
+  }
+  return r ^ 0xff000000;
+}
+
+const tableSize = 256;
+const crc32Table = new Uint32Array(tableSize);
+for (let i = 0; i < tableSize; ++i) {
+  crc32Table[i] = crc32ForByte(i);
+}
+
+export function crc32(dataIterable: ArrayBuffer | number[]) {
+  let dataBytes = new Uint8Array(dataIterable);
+  let crc = 0;
+  for (let i = 0; i < dataBytes.byteLength; ++i) {
+    const crcLowByte = crc & 0x000000ff;
+    const dataByte = dataBytes[i];
+    const tableIndex = crcLowByte ^ dataByte;
+    // The last >>> is to convert this into an unsigned 32-bit integer.
+    crc = (crc32Table[tableIndex] ^ (crc >>> 8)) >>> 0;
+  }
+  return crc;
+}
+
+// This is a small test function for the CRC32 implementation, not normally called but left in
+// for debugging purposes. We know the expected CRC32 of [97, 98, 99, 100, 101] is 2240272485,
+// or 0x8587d865, so if anything else is output we know there's an error in the implementation.
+export function testCrc32() {
+  const testArray = [97, 98, 99, 100, 101];
+  const testArrayCrc32 = crc32(testArray);
+  _console.log("CRC32 for [97, 98, 99, 100, 101] is 0x" + testArrayCrc32.toString(16) + " (" + testArrayCrc32 + ")");
+}

package/src/utils/environment.ts

@@ -0,0 +1,46 @@
+type ENVIRONMENT_FLAG = "__BRILLIANTSOLE__DEV__" | "__BRILLIANTSOLE__PROD__";
+const __BRILLIANTSOLE__ENVIRONMENT__: ENVIRONMENT_FLAG = "__BRILLIANTSOLE__DEV__";
+
+//@ts-expect-error
+const isInProduction = __BRILLIANTSOLE__ENVIRONMENT__ == "__BRILLIANTSOLE__PROD__";
+const isInDev = __BRILLIANTSOLE__ENVIRONMENT__ == "__BRILLIANTSOLE__DEV__";
+
+// https://github.com/flexdinesh/browser-or-node/blob/master/src/index.ts
+const isInBrowser = typeof window !== "undefined" && typeof window?.document !== "undefined";
+const isInNode = typeof process !== "undefined" && process?.versions?.node != null;
+
+const userAgent = (isInBrowser && navigator.userAgent) || "";
+
+let isBluetoothSupported = false;
+if (isInBrowser) {
+  isBluetoothSupported = Boolean(navigator.bluetooth);
+} else if (isInNode) {
+  isBluetoothSupported = true;
+}
+
+const isInBluefy = isInBrowser && /Bluefy/i.test(userAgent);
+const isInWebBLE = isInBrowser && /WebBLE/i.test(userAgent);
+
+const isAndroid = isInBrowser && /Android/i.test(userAgent);
+const isSafari = isInBrowser && /Safari/i.test(userAgent) && !/Chrome/i.test(userAgent);
+
+const isIOS = isInBrowser && /iPad|iPhone|iPod/i.test(userAgent);
+const isMac = isInBrowser && /Macintosh/i.test(userAgent);
+
+// @ts-expect-error
+const isInLensStudio = !isInBrowser && !isInNode && typeof global !== "undefined" && typeof Studio !== "undefined";
+
+export {
+  isInDev,
+  isInProduction,
+  isInBrowser,
+  isInNode,
+  isAndroid,
+  isInBluefy,
+  isInWebBLE,
+  isSafari,
+  isInLensStudio,
+  isIOS,
+  isMac,
+  isBluetoothSupported,
+};