@hangtime/grip-connect 0.2.3 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hangtime/grip-connect",
-  "version": "0.2.3",
+  "version": "0.2.6",
   "description": "A client that can establish connections with various Force-Sensing Hangboards/Plates used by climbers for strength measurement. Examples of such hangboards include the Griptonite Motherboard, Climbro, SmartBoard, Entralpi or Tindeq Progressor",
   "main": "src/index.ts",
   "scripts": {
@@ -19,13 +19,13 @@
     "hangboard",
     "hangboarding",
     "beastmaker",
-    "motherboard"
+    "motherboard",
+    "tindeq",
+    "progressor",
+    "entralpi"
   ],
   "bugs": {
     "url": "https://github.com/Stevie-Ray/hangtime-grip-connect/issues"
   },
-  "homepage": "https://stevie-ray.github.io/hangtime-grip-connect/",
-  "dependencies": {
-    "@aksel/structjs": "^1.0.0"
-  }
+  "homepage": "https://stevie-ray.github.io/hangtime-grip-connect/"
 }

package/src/data.js

@@ -1,7 +1,7 @@
 import { notifyCallback } from "./notify";
 import { ProgressorCommands, ProgressorResponses } from "./commands/progressor";
 import { lastWrite } from "./write";
-import struct from "@aksel/structjs";
+import struct from "./struct";
 const PACKET_LENGTH = 32;
 const NUM_SAMPLES = 3;
 export const CALIBRATION = [[], [], [], []];
@@ -120,7 +120,7 @@ export const handleProgressorData = (uuid, data) => {
                 notifyCallback({
                     uuid: uuid,
                     value: {
-                        massTotal: Math.max(-1000, weight - tare).toFixed(1),
+                        massTotal: Math.max(-1000, Number(weight) - tare).toFixed(1),
                     },
                 });
             }

package/src/data.ts

@@ -1,7 +1,7 @@
 import { notifyCallback } from "./notify"
 import { ProgressorCommands, ProgressorResponses } from "./commands/progressor"
 import { lastWrite } from "./write"
-import struct from "@aksel/structjs"
+import struct from "./struct"
 
 const PACKET_LENGTH: number = 32
 const NUM_SAMPLES: number = 3
@@ -145,7 +145,7 @@ export const handleProgressorData = (uuid: string, data: DataView): void => {
         notifyCallback({
           uuid: uuid,
           value: {
-            massTotal: Math.max(-1000, weight - tare).toFixed(1),
+            massTotal: Math.max(-1000, Number(weight) - tare).toFixed(1),
           },
         })
       }

package/src/struct/index.d.ts

@@ -0,0 +1,9 @@
+export default function struct(format: string): Readonly<{
+    unpack: (arrb: ArrayBuffer) => unknown[];
+    pack: (...values: unknown[]) => ArrayBuffer;
+    unpack_from: (arrb: ArrayBuffer, offs: number) => unknown[];
+    pack_into: (arrb: ArrayBuffer, offs: number, ...values: unknown[]) => void;
+    iter_unpack: (arrb: ArrayBuffer) => IterableIterator<unknown[]>;
+    format: string;
+    size: number;
+}>;

package/src/struct/index.js

@@ -0,0 +1,176 @@
+const rechk = /^([<>])?(([1-9]\d*)?([xcbB?hHiIfdsp]))*$/;
+const refmt = /([1-9]\d*)?([xcbB?hHiIfdsp])/g;
+const str = (v, o, c) => String.fromCharCode(...Array.from(new Uint8Array(v.buffer, v.byteOffset + o, c)));
+const rts = (v, o, c, s) => new Uint8Array(v.buffer, v.byteOffset + o, c).set(s.split("").map((str) => str.charCodeAt(0)));
+const pst = (v, o, c) => str(v, o + 1, Math.min(v.getUint8(o), c - 1));
+const tsp = (v, o, c, s) => {
+    v.setUint8(o, s.length);
+    rts(v, o + 1, c - 1, s);
+};
+const lut = (le) => ({
+    x: (c) => [
+        1,
+        c,
+        () => ({
+            u: () => undefined,
+            p: () => undefined,
+        }),
+    ],
+    c: (c) => [
+        c,
+        1,
+        (o) => ({
+            u: (v) => str(v, o, 1),
+            p: (v, s) => rts(v, o, 1, s),
+        }),
+    ],
+    "?": (c) => [
+        c,
+        1,
+        (o) => ({
+            u: (v) => Boolean(v.getUint8(o)),
+            p: (v, B) => v.setUint8(o, B ? 1 : 0),
+        }),
+    ],
+    b: (c) => [
+        c,
+        1,
+        (o) => ({
+            u: (v) => v.getInt8(o),
+            p: (v, b) => v.setInt8(o, b),
+        }),
+    ],
+    B: (c) => [
+        c,
+        1,
+        (o) => ({
+            u: (v) => v.getUint8(o),
+            p: (v, B) => v.setUint8(o, B),
+        }),
+    ],
+    h: (c) => [
+        c,
+        2,
+        (o) => ({
+            u: (v) => v.getInt16(o, le),
+            p: (v, h) => v.setInt16(o, h, le),
+        }),
+    ],
+    H: (c) => [
+        c,
+        2,
+        (o) => ({
+            u: (v) => v.getUint16(o, le),
+            p: (v, H) => v.setUint16(o, H, le),
+        }),
+    ],
+    i: (c) => [
+        c,
+        4,
+        (o) => ({
+            u: (v) => v.getInt32(o, le),
+            p: (v, i) => v.setInt32(o, i, le),
+        }),
+    ],
+    I: (c) => [
+        c,
+        4,
+        (o) => ({
+            u: (v) => v.getUint32(o, le),
+            p: (v, I) => v.setUint32(o, I, le),
+        }),
+    ],
+    f: (c) => [
+        c,
+        4,
+        (o) => ({
+            u: (v) => v.getFloat32(o, le),
+            p: (v, f) => v.setFloat32(o, f, le),
+        }),
+    ],
+    d: (c) => [
+        c,
+        8,
+        (o) => ({
+            u: (v) => v.getFloat64(o, le),
+            p: (v, d) => v.setFloat64(o, d, le),
+        }),
+    ],
+    s: (c) => [
+        1,
+        c,
+        (o) => ({
+            u: (v) => str(v, o, c),
+            p: (v, s) => rts(v, o, c, s.slice(0, c)),
+        }),
+    ],
+    p: (c) => [
+        1,
+        c,
+        (o) => ({
+            u: (v) => pst(v, o, c),
+            p: (v, s) => tsp(v, o, c, s.slice(0, c - 1)),
+        }),
+    ],
+});
+const errbuf = new RangeError("Structure larger than remaining buffer");
+const errval = new RangeError("Not enough values for structure");
+export default function struct(format) {
+    const fns = [];
+    let size = 0;
+    let m = rechk.exec(format);
+    if (!m) {
+        throw new RangeError("Invalid format string");
+    }
+    const t = lut("<" === m[1]);
+    const lu = (n, c) => t[c](n ? parseInt(n, 10) : 1);
+    while ((m = refmt.exec(format))) {
+        // eslint-disable-next-line no-extra-semi
+        ;
+        ((r, s, f) => {
+            for (let i = 0; i < r; ++i, size += s) {
+                if (f) {
+                    fns.push(f(size));
+                }
+            }
+        })(...lu(...m.slice(1)));
+    }
+    const unpack_from = (arrb, offs) => {
+        if (arrb.byteLength < (offs | 0) + size) {
+            throw errbuf;
+        }
+        const v = new DataView(arrb, offs | 0);
+        return fns.map((f) => f.u(v));
+    };
+    const pack_into = (arrb, offs, ...values) => {
+        if (values.length < fns.length) {
+            throw errval;
+        }
+        if (arrb.byteLength < offs + size) {
+            throw errbuf;
+        }
+        const v = new DataView(arrb, offs);
+        new Uint8Array(arrb, offs, size).fill(0);
+        fns.forEach((f, i) => f.p(v, values[i]));
+    };
+    const pack = (...values) => {
+        const b = new ArrayBuffer(size);
+        pack_into(b, 0, ...values);
+        return b;
+    };
+    const unpack = (arrb) => unpack_from(arrb, 0);
+    function* iter_unpack(arrb) {
+        for (let offs = 0; offs + size <= arrb.byteLength; offs += size) {
+            yield unpack_from(arrb, offs);
+        }
+    }
+    return Object.freeze({
+        unpack,
+        pack,
+        unpack_from,
+        pack_into,
+        iter_unpack,
+        format,
+        size,
+    });
+}

package/src/struct/index.ts

@@ -0,0 +1,215 @@
+const rechk: RegExp = /^([<>])?(([1-9]\d*)?([xcbB?hHiIfdsp]))*$/
+const refmt: RegExp = /([1-9]\d*)?([xcbB?hHiIfdsp])/g
+
+const str = (v: DataView, o: number, c: number): string =>
+  String.fromCharCode(...Array.from(new Uint8Array(v.buffer, v.byteOffset + o, c)))
+
+const rts = (v: DataView, o: number, c: number, s: string): void =>
+  new Uint8Array(v.buffer, v.byteOffset + o, c).set(s.split("").map((str) => str.charCodeAt(0)))
+
+const pst = (v: DataView, o: number, c: number): string => str(v, o + 1, Math.min(v.getUint8(o), c - 1))
+
+const tsp = (v: DataView, o: number, c: number, s: string): void => {
+  v.setUint8(o, s.length)
+  rts(v, o + 1, c - 1, s)
+}
+
+interface FormatFn {
+  u: (v: DataView) => unknown
+  p: (v: DataView, value: unknown) => void
+}
+
+interface LUT {
+  [key: string]: (c: number) => [number, number, (o: number) => FormatFn]
+}
+
+const lut = (le: boolean): LUT => ({
+  x: (c: number) =>
+    [
+      1,
+      c,
+      () => ({
+        u: () => undefined,
+        p: () => undefined,
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  c: (c: number) =>
+    [
+      c,
+      1,
+      (o: number) => ({
+        u: (v: DataView) => str(v, o, 1),
+        p: (v: DataView, s: string) => rts(v, o, 1, s),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  "?": (c: number) =>
+    [
+      c,
+      1,
+      (o: number) => ({
+        u: (v: DataView) => Boolean(v.getUint8(o)),
+        p: (v: DataView, B: boolean) => v.setUint8(o, B ? 1 : 0),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  b: (c: number) =>
+    [
+      c,
+      1,
+      (o: number) => ({
+        u: (v: DataView) => v.getInt8(o),
+        p: (v: DataView, b: number) => v.setInt8(o, b),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  B: (c: number) =>
+    [
+      c,
+      1,
+      (o: number) => ({
+        u: (v: DataView) => v.getUint8(o),
+        p: (v: DataView, B: number) => v.setUint8(o, B),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  h: (c: number) =>
+    [
+      c,
+      2,
+      (o: number) => ({
+        u: (v: DataView) => v.getInt16(o, le),
+        p: (v: DataView, h: number) => v.setInt16(o, h, le),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  H: (c: number) =>
+    [
+      c,
+      2,
+      (o: number) => ({
+        u: (v: DataView) => v.getUint16(o, le),
+        p: (v: DataView, H: number) => v.setUint16(o, H, le),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  i: (c: number) =>
+    [
+      c,
+      4,
+      (o: number) => ({
+        u: (v: DataView) => v.getInt32(o, le),
+        p: (v: DataView, i: number) => v.setInt32(o, i, le),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  I: (c: number) =>
+    [
+      c,
+      4,
+      (o: number) => ({
+        u: (v: DataView) => v.getUint32(o, le),
+        p: (v: DataView, I: number) => v.setUint32(o, I, le),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  f: (c: number) =>
+    [
+      c,
+      4,
+      (o: number) => ({
+        u: (v: DataView) => v.getFloat32(o, le),
+        p: (v: DataView, f: number) => v.setFloat32(o, f, le),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  d: (c: number) =>
+    [
+      c,
+      8,
+      (o: number) => ({
+        u: (v: DataView) => v.getFloat64(o, le),
+        p: (v: DataView, d: number) => v.setFloat64(o, d, le),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  s: (c: number) =>
+    [
+      1,
+      c,
+      (o: number) => ({
+        u: (v: DataView) => str(v, o, c),
+        p: (v: DataView, s: string) => rts(v, o, c, s.slice(0, c)),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+  p: (c: number) =>
+    [
+      1,
+      c,
+      (o: number) => ({
+        u: (v: DataView) => pst(v, o, c),
+        p: (v: DataView, s: string) => tsp(v, o, c, s.slice(0, c - 1)),
+      }),
+    ] as [number, number, (o: number) => FormatFn],
+})
+
+const errbuf: RangeError = new RangeError("Structure larger than remaining buffer")
+const errval: RangeError = new RangeError("Not enough values for structure")
+
+export default function struct(format: string) {
+  const fns: FormatFn[] = []
+  let size: number = 0
+  let m: RegExpExecArray | null = rechk.exec(format)
+
+  if (!m) {
+    throw new RangeError("Invalid format string")
+  }
+
+  const t: LUT = lut("<" === m[1])
+  const lu = (n: string, c: string): [number, number, (o: number) => FormatFn] => t[c](n ? parseInt(n, 10) : 1)
+
+  while ((m = refmt.exec(format))) {
+    // eslint-disable-next-line no-extra-semi
+    ;((r: number, s: number, f: (o: number) => FormatFn) => {
+      for (let i = 0; i < r; ++i, size += s) {
+        if (f) {
+          fns.push(f(size))
+        }
+      }
+    })(...lu(...(m.slice(1) as [string, string])))
+  }
+
+  const unpack_from = (arrb: ArrayBuffer, offs: number): unknown[] => {
+    if (arrb.byteLength < (offs | 0) + size) {
+      throw errbuf
+    }
+    const v = new DataView(arrb, offs | 0)
+    return fns.map((f) => f.u(v))
+  }
+
+  const pack_into = (arrb: ArrayBuffer, offs: number, ...values: unknown[]): void => {
+    if (values.length < fns.length) {
+      throw errval
+    }
+    if (arrb.byteLength < offs + size) {
+      throw errbuf
+    }
+    const v = new DataView(arrb, offs)
+    new Uint8Array(arrb, offs, size).fill(0)
+    fns.forEach((f, i) => f.p(v, values[i]))
+  }
+
+  const pack = (...values: unknown[]): ArrayBuffer => {
+    const b = new ArrayBuffer(size)
+    pack_into(b, 0, ...values)
+    return b
+  }
+
+  const unpack = (arrb: ArrayBuffer): unknown[] => unpack_from(arrb, 0)
+
+  function* iter_unpack(arrb: ArrayBuffer): IterableIterator<unknown[]> {
+    for (let offs = 0; offs + size <= arrb.byteLength; offs += size) {
+      yield unpack_from(arrb, offs)
+    }
+  }
+
+  return Object.freeze({
+    unpack,
+    pack,
+    unpack_from,
+    pack_into,
+    iter_unpack,
+    format,
+    size,
+  })
+}

package/src/declarations.d.ts

@@ -1 +0,0 @@
-declare module "@aksel/structjs"