@alexgyver/bson 1.0.0 → 1.0.2

package/README.md

@@ -1,2 +1,19 @@
 # bson.js
- 
+Распаковщик бинарного JSON для библиотеки [BSON](https://github.com/GyverLibs/BSON).
+
+> npm i @alexgyver/bson
+
+```js
+const codes = [
+    'some',
+    'string',
+    'constants',
+];
+
+let json;
+const res = await fetch(...);
+
+try {
+    json = decodeBson(new Uint8Array(await res.arrayBuffer()), codes);
+} catch (e) { }
+```

package/bson.js

@@ -6,119 +6,130 @@
 export default function decodeBson(b, codes = []) {
     if (!b || !(b instanceof Uint8Array)) return null;
     if (!b.length) return {};
-    let bins = [];
 
-    const BS_KEY_CODE = (0 << 5);
-    const BS_KEY_STR = (1 << 5);
-    const BS_VAL_CODE = (2 << 5);
-    const BS_VAL_STR = (3 << 5);
-    const BS_VAL_INT = (4 << 5);
-    const BS_VAL_FLOAT = (5 << 5);
+    const BS_STRING = (0 << 5);
+    const BS_BOOLEAN = (1 << 5);
+    const BS_INTEGER = (2 << 5);
+    const BS_FLOAT = (3 << 5);
+    const BS_CODE = (4 << 5);
+    const BS_BINARY = (5 << 5);
     const BS_CONTAINER = (6 << 5);
-    const BS_BINARY = (7 << 5);
-    const BS_BIN_PREFIX = "__BSON_BINARY";
 
     const BS_CONT_OBJ = (1 << 4);
     const BS_CONT_OPEN = (1 << 3);
+    const BS_NEGATIVE = (1 << 4);
+    const BS_BIN_PREFIX = "__BSON_BINARY";
 
-    function u32toFloat(u32) {
-        return new Float32Array(new Uint32Array([u32]).buffer)[0];
-    }
     function unpack5(msb5, lsb) {
         return ((msb5 << 8) | lsb) >>> 0;
     }
-    function makeBins(obj) {
+    function makeBins(obj, bins) {
         if (typeof obj !== 'object') return;
         for (let k in obj) {
             if (typeof obj[k] === "object" && obj[k] !== null) {
-                makeBins(obj[k]);
+                makeBins(obj[k], bins);
             } else if (typeof obj[k] === "string" && obj[k].startsWith(BS_BIN_PREFIX)) {
                 obj[k] = bins[obj[k].split('#')[1]];
             }
         }
     }
 
+    let bins = [];
+    let stack = [];
+    let keyf = true;
     let s = '';
-    for (let i = 0; i < b.length; i++) {
-        const type = b[i] & 0b11100000;
-        const data = b[i] & 0b00011111;
-
-        switch (type) {
-            case BS_CONTAINER:
-                if (data & BS_CONT_OPEN) {
-                    s += (data & BS_CONT_OBJ) ? '{' : '[';
-                } else {
-                    if (s[s.length - 1] == ',') s = s.slice(0, -1);
-                    s += (data & BS_CONT_OBJ) ? '}' : ']';
-                    s += ',';
-                }
-                break;
-
-            case BS_KEY_CODE:
-            case BS_VAL_CODE:
-                s += '"' + codes[unpack5(data, b[++i])] + '"';
-                s += (type == BS_KEY_CODE) ? ':' : ',';
-                break;
-
-            case BS_KEY_STR:
-            case BS_VAL_STR: {
-                let len = unpack5(data, b[++i]);
-                i++;
-                let txt = new TextDecoder().decode(b.slice(i, i + len));
-                txt = txt.replaceAll(/([^\\])\\([^\"\\nrt])/ig, "$1\\\\$2")
-                    .replaceAll(/\t/ig, "\\t")
-                    .replaceAll(/\n/ig, "\\n")
-                    .replaceAll(/\r/ig, "\\r")
-                    .replaceAll(/([^\\])(")/ig, '$1\\"');
-                s += '"' + txt + '"';
-                s += (type == BS_KEY_STR) ? ':' : ',';
-                i += len - 1;
-            } break;
-
-            case BS_VAL_INT: {
-                if (data & 0b10000) s += '-';
-                let len = data & 0b01111;
-                let v = BigInt(0);
-                for (let j = 0; j < len; j++) {
-                    v |= BigInt(b[++i]) << BigInt(j * 8);
-                }
-                s += v;
-                s += ',';
-            } break;
-
-            case BS_VAL_FLOAT: {
-                let v = 0;
-                for (let j = 0; j < 4; j++) {
-                    v |= b[++i] << (j * 8);
-                }
-                let f = u32toFloat(v);
-                if (isNaN(f)) {
-                    s += '"NaN"';
-                } else if (!isFinite(f)) {
-                    s += '"Infinity"';
-                } else {
-                    s += f.toFixed(data);
-                }
+
+    try {
+        for (let i = 0; i < b.length; i++) {
+            const type = b[i] & 0b11100000;
+            const data = b[i] & 0b00011111;
+
+            switch (type) {
+
+                case BS_CONTAINER:
+                    if (data & BS_CONT_OPEN) {
+                        let t = (data & BS_CONT_OBJ) ? '{' : '[';
+                        s += t;
+                        stack.push(t);
+                    } else {
+                        if (s[s.length - 1] == ',') s = s.slice(0, -1);
+                        let t = (data & BS_CONT_OBJ) ? '}' : ']';
+                        s += t + ',';
+                        stack.pop();
+                    }
+                    keyf = true;
+                    continue;
+
+                case BS_CODE:
+                    s += '"' + codes[unpack5(data, b[++i])] + '"';
+                    break;
+
+                case BS_STRING: {
+                    let len = unpack5(data, b[++i]);
+                    i++;
+                    let txt = new TextDecoder().decode(b.slice(i, i + len));
+                    txt = txt.replaceAll(/([^\\])\\([^\"\\nrt])/ig, "$1\\\\$2")
+                        .replaceAll(/\t/ig, "\\t")
+                        .replaceAll(/\n/ig, "\\n")
+                        .replaceAll(/\r/ig, "\\r")
+                        .replaceAll(/([^\\])(")/ig, '$1\\"');
+                    s += '"' + txt + '"';
+                    i += len - 1;
+                } break;
+
+                case BS_INTEGER: {
+                    if (data & BS_NEGATIVE) s += '-';
+                    let len = data & 0b1111;
+                    let v = BigInt(0);
+                    for (let j = 0; j < len; j++) {
+                        v |= BigInt(b[++i]) << BigInt(j * 8);
+                    }
+                    s += v;
+                } break;
+
+                case BS_BOOLEAN:
+                    s += (data & 0b1) ? 'true' : 'false';
+                    break;
+
+                case BS_FLOAT: {
+                    let v = 0;
+                    for (let j = 0; j < 4; j++) {
+                        v |= b[++i] << (j * 8);
+                    }
+                    let f = new Float32Array(new Uint32Array([v]).buffer)[0];
+                    s += (isNaN(f) || !isFinite(f)) ? 'null' : f.toFixed(data);
+                } break;
+
+                case BS_BINARY: {
+                    let len = unpack5(data, b[++i]);
+                    i++;
+                    s += '"' + BS_BIN_PREFIX + '#' + bins.length + '"';
+                    bins.push(b.slice(i, i + len));
+                    i += len - 1;
+                } break;
+
+            }
+
+            if (stack[stack.length - 1] === '{') {
+                s += keyf ? ':' : ',';
+                keyf = !keyf;
+            } else {
                 s += ',';
-            } break;
-
-            case BS_BINARY: {
-                let len = unpack5(data, b[++i]);
-                i++;
-                s += '"' + BS_BIN_PREFIX + '#' + bins.length + '",';
-                bins.push(b.slice(i, i + len));
-                i += len - 1;
-            } break;
+            }
         }
+    } catch (e) {
+        console.log(s);
+        throw new Error("BSON decode error");
     }
+
     if (s[s.length - 1] == ',') s = s.slice(0, -1);
 
     try {
         let obj = JSON.parse(s);
-        if (bins.length) makeBins(obj);
+        if (bins.length) makeBins(obj, bins);
         return obj;
     } catch (e) {
         console.log(s);
-        throw new Error("JSON error")
+        throw new Error("JSON parse error");
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alexgyver/bson",
-  "version": "1.0.0",
-  "description": "Decode BSON from GSON Arduino library",
+  "version": "1.0.2",
+  "description": "Decode BSON from BSON Arduino library",
   "main": "./bson.js",
   "module": "./bson.js",
   "types": "./bson.js",