@alexgyver/bson 2.0.1 → 2.1.0

package/bson.js

@@ -1,39 +1,52 @@
+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_NULL = (7 << 5);
+
+const BS_CONT_OBJ = (1 << 4);
+const BS_CONT_OPEN = (1 << 3);
+const BS_CONT_ARR = (1 << 2);
+const BS_CONT_CLOSE = (1 << 1);
+
+const BS_MAX_LEN = 0b0001111111111111;
+
+const BS_TYPE_MASK = 0b11100000;
+const BS_TYPE = x => x & BS_TYPE_MASK;
+const BS_DATA_MASK = 0b00011111;
+const BS_DATA = x => x & BS_DATA_MASK;
+
+const BS_BOOLV_MASK = 0b1;
+const BS_BOOLV = x => x & BS_BOOLV_MASK;
+
+const BS_NEG_MASK = 0b10000;
+const BS_NEGATIVE = x => x & BS_NEG_MASK;
+const BS_SIZE_MASK = 0b01111;
+const BS_SIZE = x => x & BS_SIZE_MASK;
+
+const BS_FLOAT_SIZE = 4;
+const BS_DEC_MASK = 0b1111;
+const BS_DECIMAL = x => x & BS_DEC_MASK;
+
+const BS_D16_MSB = x => (x >> 8) & BS_DATA_MASK;
+const BS_D16_LSB = x => x & 0xff;
+const BS_D16_MERGE = (msb5, lsb) => ((msb5 << 8) | lsb) >>> 0;
+
+const BS_BIN_PREFIX = "__BSON_BIN_";
+const BS_CODE_PREFIX = "__BSON_CODE_";
+
 /**
  * @param {Uint8Array} b
  * @param {Array} codes
  * @returns {Object}
  */
-export default function decodeBson(b, codes = []) {
+export function decodeBson(b, codes = []) {
     if (!b || !(b instanceof Uint8Array)) return null;
     if (!b.length) return {};
 
-    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_CONT_OBJ = (1 << 4);
-    const BS_CONT_OPEN = (1 << 3);
-    const BS_NEGATIVE = (1 << 4);
-    const BS_BIN_PREFIX = "__BSON_BINARY";
-
-    function unpack5(msb5, lsb) {
-        return ((msb5 << 8) | lsb) >>> 0;
-    }
-    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], 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;
@@ -41,8 +54,8 @@ export default function decodeBson(b, codes = []) {
 
     try {
         for (let i = 0; i < b.length; i++) {
-            const type = b[i] & 0b11100000;
-            const data = b[i] & 0b00011111;
+            const type = BS_TYPE(b[i]);
+            const data = BS_DATA(b[i]);
 
             switch (type) {
 
@@ -61,24 +74,18 @@ export default function decodeBson(b, codes = []) {
                     continue;
 
                 case BS_CODE:
-                    s += '"' + codes[unpack5(data, b[++i])] + '"';
+                    s += '"' + codes[BS_D16_MERGE(data, b[++i])] + '"';
                     break;
 
                 case BS_STRING: {
-                    let len = unpack5(data, b[++i]);
-                    let txt = new TextDecoder().decode(b.slice(i + 1, i + 1 + 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 + '"';
+                    let len = BS_D16_MERGE(data, b[++i]);
+                    s += JSON.stringify(new TextDecoder().decode(b.slice(i + 1, i + 1 + len)));
                     i += len;
                 } break;
 
                 case BS_INTEGER: {
-                    if (data & BS_NEGATIVE) s += '-';
-                    let len = data & 0b1111;
+                    if (BS_NEGATIVE(data)) s += '-';
+                    let len = BS_SIZE(data);
                     let u8 = new Uint8Array(8);
                     u8.set(b.slice(i + 1, i + 1 + len));
                     s += new BigUint64Array(u8.buffer)[0];
@@ -86,19 +93,24 @@ export default function decodeBson(b, codes = []) {
                 } break;
 
                 case BS_BOOLEAN:
-                    s += (data & 0b1) ? 'true' : 'false';
+                    s += BS_BOOLV(data) ? 'true' : 'false';
+                    break;
+
+                case BS_NULL:
+                    s += 'null';
                     break;
 
                 case BS_FLOAT: {
-                    let f = new Float32Array(b.slice(i + 1, i + 1 + 4).buffer)[0];
-                    s += (isNaN(f) || !isFinite(f)) ? 'null' : f.toFixed(data);
-                    i += 4;
+                    let f = new DataView(b.buffer, b.byteOffset + i + 1, BS_FLOAT_SIZE).getFloat32(0, true);
+                    s += (isNaN(f) || !isFinite(f)) ? 'null' : f.toFixed(BS_DECIMAL(data));
+                    i += BS_FLOAT_SIZE;
+
                 } break;
 
                 case BS_BINARY: {
-                    let len = unpack5(data, b[++i]);
+                    let len = BS_D16_MERGE(data, b[++i]);
                     i++;
-                    s += '"' + BS_BIN_PREFIX + '#' + bins.length + '"';
+                    s += '"' + BS_BIN_PREFIX + bins.length + '"';
                     bins.push(b.slice(i, i + len));
                     i += len - 1;
                 } break;
@@ -113,7 +125,7 @@ export default function decodeBson(b, codes = []) {
             }
         }
     } catch (e) {
-        console.log(e, s);
+        console.error(e, s);
         throw new Error("BSON decode error");
     }
 
@@ -121,10 +133,107 @@ export default function decodeBson(b, codes = []) {
 
     try {
         let obj = JSON.parse(s);
-        if (bins.length) makeBins(obj, bins);
+        if (bins.length) _makeBins(obj, bins);
         return obj;
     } catch (e) {
-        console.log(e, s);
+        console.error(e, s);
         throw new Error("JSON parse error");
     }
+}
+
+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], bins);
+        } else if (typeof obj[k] === "string" && obj[k].startsWith(BS_BIN_PREFIX)) {
+            obj[k] = bins[obj[k].slice(BS_BIN_PREFIX.length)];
+        }
+    }
+}
+
+/**
+ * @param {*} val
+ * @returns {Uint8Array}
+ */
+export function encodeBson(val) {
+    let arr = [];
+    _encode(val, arr);
+    return Uint8Array.from(arr);
+}
+
+function _encode(val, arr) {
+    if (Array.isArray(val)) {
+        arr.push(BS_CONTAINER | BS_CONT_ARR | BS_CONT_OPEN);
+        val.forEach(v => _encode(v, arr));
+        arr.push(BS_CONTAINER | BS_CONT_ARR | BS_CONT_CLOSE);
+        return;
+    }
+
+    switch (typeof val) {
+        case 'object':
+            if (val === null) {
+                arr.push(BS_NULL);
+            } else if (val instanceof Uint8Array) {
+                const len = Math.min(val.length, BS_MAX_LEN);
+                arr.push(BS_BINARY | BS_D16_MSB(len));
+                arr.push(BS_D16_LSB(len));
+                arr.push(...val.slice(0, len));
+            } else {
+                arr.push(BS_CONTAINER | BS_CONT_OBJ | BS_CONT_OPEN);
+                for (const [key, value] of Object.entries(val)) {
+                    _encode(key, arr);
+                    _encode(value, arr);
+                }
+                arr.push(BS_CONTAINER | BS_CONT_OBJ | BS_CONT_CLOSE);
+            }
+            break;
+
+        case 'bigint':
+        case 'number':
+            if (Number.isInteger(val)) {
+                val = BigInt(val);
+                const neg = val < 0;
+                if (neg) val = -val;
+                let bytes = [];
+                while (val) {
+                    bytes.push(Number(val & 0xFFn));
+                    val >>= 8n;
+                }
+                arr.push(BS_INTEGER | (neg ? BS_NEG_MASK : 0) | bytes.length);
+                arr.push(...bytes);
+            } else {
+                const buffer = new ArrayBuffer(BS_FLOAT_SIZE);
+                new DataView(buffer).setFloat32(0, val, true);
+                arr.push(BS_FLOAT | 4);
+                arr.push(...new Uint8Array(buffer));
+            }
+            break;
+
+        case 'string':
+            if (val.startsWith(BS_CODE_PREFIX)) {
+                let code = Number(val.slice(BS_CODE_PREFIX.length));
+                arr.push(BS_CODE | BS_D16_MSB(code));
+                arr.push(BS_D16_LSB(code));
+            } else {
+                const bytes = new TextEncoder().encode(val);
+                const len = Math.min(bytes.length, BS_MAX_LEN);
+                arr.push(BS_STRING | BS_D16_MSB(len));
+                arr.push(BS_D16_LSB(len));
+                arr.push(...bytes.slice(0, len));
+            }
+            break;
+
+        case 'boolean':
+            arr.push(BS_BOOLEAN | (val ? 1 : 0));
+            break;
+
+        default:
+            arr.push(BS_NULL);
+            break;
+    }
+}
+
+export function getCode(name, codes) {
+    return BS_CODE_PREFIX + codes.indexOf(name);
 }

package/bson.min.js

@@ -0,0 +1 @@
+var e={d:(t,r)=>{for(var n in r)e.o(r,n)&&!e.o(t,n)&&Object.defineProperty(t,n,{enumerable:!0,get:r[n]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t)},t={};e.d(t,{$R:()=>U,QC:()=>C,lo:()=>F});const r=0,n=32,s=64,o=96,a=128,c=160,i=192,l=224,u=16,h=8,f=4,p=2,b=8191,g=e=>224&e,y=e=>31&e,d=e=>1&e,w=16,O=e=>e&w,N=e=>15&e,k=4,A=e=>15&e,B=e=>e>>8&31,m=e=>255&e,_=(e,t)=>(e<<8|t)>>>0,j="__BSON_BIN_",x="__BSON_CODE_";function F(e,t=[]){if(!(e&&e instanceof Uint8Array))return null;if(!e.length)return{};let f=[],p=[],b=!0,w="";try{for(let B=0;B<e.length;B++){const m=g(e[B]),x=y(e[B]);switch(m){case i:if(x&h){let e=x&u?"{":"[";w+=e,p.push(e)}else","==w[w.length-1]&&(w=w.slice(0,-1)),w+=(x&u?"}":"]")+",",p.pop();b=!0;continue;case a:w+='"'+t[_(x,e[++B])]+'"';break;case r:{let t=_(x,e[++B]);w+=JSON.stringify((new TextDecoder).decode(e.slice(B+1,B+1+t))),B+=t}break;case s:{O(x)&&(w+="-");let t=N(x),r=new Uint8Array(8);r.set(e.slice(B+1,B+1+t)),w+=new BigUint64Array(r.buffer)[0],B+=t}break;case n:w+=d(x)?"true":"false";break;case l:w+="null";break;case o:{let t=new DataView(e.buffer,e.byteOffset+B+1,k).getFloat32(0,!0);w+=isNaN(t)||!isFinite(t)?"null":t.toFixed(A(x)),B+=k}break;case c:{let t=_(x,e[++B]);B++,w+='"'+j+f.length+'"',f.push(e.slice(B,B+t)),B+=t-1}}"{"===p[p.length-1]?(w+=b?":":",",b=!b):w+=","}}catch(e){throw console.error(e,w),new Error("BSON decode error")}","==w[w.length-1]&&(w=w.slice(0,-1));try{let e=JSON.parse(w);return f.length&&S(e,f),e}catch(e){throw console.error(e,w),new Error("JSON parse error")}}function S(e,t){if("object"==typeof e)for(let r in e)"object"==typeof e[r]&&null!==e[r]?S(e[r],t):"string"==typeof e[r]&&e[r].startsWith(j)&&(e[r]=t[e[r].slice(j.length)])}function U(e){let t=[];return E(e,t),Uint8Array.from(t)}function E(e,t){if(Array.isArray(e))return t.push(i|f|h),e.forEach(e=>E(e,t)),void t.push(i|f|p);switch(typeof e){case"object":if(null===e)t.push(l);else if(e instanceof Uint8Array){const r=Math.min(e.length,b);t.push(c|B(r)),t.push(m(r)),t.push(...e.slice(0,r))}else{t.push(i|u|h);for(const[r,n]of Object.entries(e))E(r,t),E(n,t);t.push(i|u|p)}break;case"bigint":case"number":if(Number.isInteger(e)){const r=(e=BigInt(e))<0;r&&(e=-e);let n=[];for(;e;)n.push(Number(0xFFn&e)),e>>=8n;t.push(s|(r?w:0)|n.length),t.push(...n)}else{const r=new ArrayBuffer(k);new DataView(r).setFloat32(0,e,!0),t.push(4|o),t.push(...new Uint8Array(r))}break;case"string":if(e.startsWith(x)){let r=Number(e.slice(x.length));t.push(a|B(r)),t.push(m(r))}else{const n=(new TextEncoder).encode(e),s=Math.min(n.length,b);t.push(r|B(s)),t.push(m(s)),t.push(...n.slice(0,s))}break;case"boolean":t.push(n|(e?1:0));break;default:t.push(l)}}function C(e,t){return x+t.indexOf(e)}const D=t.lo,v=t.$R,I=t.QC;export{D as decodeBson,v as encodeBson,I as getCode};

package/package.json

@@ -1,14 +1,21 @@
 {
   "name": "@alexgyver/bson",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "description": "Decode BSON from BSON Arduino library",
   "main": "./bson.js",
   "module": "./bson.js",
   "types": "./bson.js",
+  "scripts": {
+    "build": "webpack --config ./webpack.config.js"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/GyverLibs/bson.js.git"
   },
+  "devDependencies": {
+    "webpack": "^5.98.0",
+    "webpack-cli": "^6.0.1"
+  },
   "author": "AlexGyver <alex@alexgyver.ru>",
   "license": "MIT"
 }

package/test.html

@@ -5,7 +5,8 @@
     <p id="out" style="white-space: break-spaces;"></p>
 
     <script type="module">
-        import decodeBson from '/bson.js';
+        import { decodeBson, encodeBson, getCode } from 'https://gyverlibs.github.io/bson.js/dist/bson.js';
+        // import { decodeBson, encodeBson, getCode } from '/bson.js';
 
         const url = 'http://192.168.1.54';
 
@@ -15,6 +16,34 @@
             'constants',
         ];
 
+        // =========== getCode ===========
+        console.log(getCode('constants', codes));
+
+        // =========== encode ===========
+        let test = {
+            int: 123,
+            float: 3.14,
+            arr: [
+                "str",
+                true,
+                1234,
+                new Uint8Array([1, 2, 3]),
+            ],
+            obj: {
+                str2: "str2",
+                true: true,
+            },
+            str3: "str3",
+            nul: null,
+            [getCode('constants', codes)]: getCode('string', codes),
+            bins: new Uint8Array([1, 2, 3]),
+        };
+
+        let enc = encodeBson(test);
+        let json = decodeBson(enc, codes);
+        console.log(json);
+
+        // =========== request ===========
         req.onclick = async () => {
             let res = await fetch(url + '/bson');
             try {

package/webpack.config.js

@@ -0,0 +1,14 @@
+module.exports = {
+    entry: './bson.js',
+    output: {
+        path: __dirname,
+        filename: 'bson.min.js',
+        library: {
+            type: 'module'
+        }
+    },
+    experiments: {
+        outputModule: true
+    },
+    mode: "production",
+};