@qbix/q 1.0.5

package/dist/methods/Q/Data/Merkle/_internal.js

@@ -0,0 +1,68 @@
+/**
+ * Shared structural helpers for Q.Data.Merkle method files.
+ * Loaded once via options.require and passed as _ to each method file.
+ * Crypto (SHA-256) is done via Q.Data.digest, available in closure as Q.
+ *
+ * Exports a plain object (sync) — no async setup needed here.
+ */
+Q.exports(function (Q) {
+
+    var _ = {
+
+        /**
+         * SHA-256 arbitrary bytes. Returns Promise<Uint8Array(32)>.
+         * payload may be Uint8Array or ArrayBuffer.
+         */
+        sha256: function (payload) {
+            return Q.Data.digest('SHA-256', payload);
+        },
+
+        /**
+         * Concatenate two Uint8Arrays.
+         */
+        concat: function (a, b) {
+            var out = new Uint8Array(a.length + b.length);
+            out.set(a, 0);
+            out.set(b, a.length);
+            return out;
+        },
+
+        /**
+         * Encode Uint8Array to lowercase hex string.
+         */
+        toHex: function (bytes) {
+            return Q.Data.toHex(bytes);
+        },
+
+        /**
+         * Hash one level of the tree: pair up nodes, hash each pair.
+         * Odd node at end is promoted (paired with itself).
+         * nodes: Array<Uint8Array>
+         * Returns Promise<Array<Uint8Array>>.
+         */
+        hashLevel: function (nodes) {
+            var pairs = [];
+            for (var i = 0; i < nodes.length; i += 2) {
+                var left  = nodes[i];
+                var right = (i + 1 < nodes.length) ? nodes[i + 1] : left;
+                pairs.push(_.sha256(_.concat(left, right)));
+            }
+            return Promise.all(pairs);
+        },
+
+        /**
+         * Reduce an array of hash nodes to a single root hash.
+         * Returns Promise<Uint8Array(32)>.
+         */
+        reduce: function (nodes) {
+            if (nodes.length === 1) {
+                return Promise.resolve(nodes[0]);
+            }
+            return _.hashLevel(nodes).then(_.reduce);
+        }
+
+    };
+
+    return _;
+
+});

package/dist/methods/Q/Data/Merkle/build.js

@@ -0,0 +1,29 @@
+/**
+ * Q.Data.Merkle.build
+ * Build a Merkle tree from an ordered array of leaf values.
+ * Each leaf is hashed with SHA-256 first.
+ * Returns the root as a hex string.
+ *
+ * @param {Array<Uint8Array|String>} leaves
+ *   If strings are passed they are UTF-8 encoded before hashing.
+ * @param {Function} [callback] (err, rootHex)
+ * @return {Q.Promise<String>}
+ */
+Q.exports(function (Q, _) {
+
+    return Q.promisify(function (leaves, callback) {
+        if (!leaves || !leaves.length) {
+            return callback(new Error('Q.Data.Merkle.build: no leaves provided'));
+        }
+
+        var enc = new TextEncoder();
+
+        Promise.all(leaves.map(function (leaf) {
+            var bytes = (typeof leaf === 'string') ? enc.encode(leaf) : leaf;
+            return _.sha256(bytes);
+        })).then(_.reduce).then(function (rootBytes) {
+            callback(null, _.toHex(rootBytes));
+        }).catch(callback);
+    }, false, 1);
+
+});

package/dist/methods/Q/Data/Merkle/proof.js

@@ -0,0 +1,50 @@
+/**
+ * Q.Data.Merkle.proof
+ * Generate a Merkle proof for the leaf at index.
+ *
+ * @param {Array<Uint8Array|String>} leaves  Full ordered leaf array
+ * @param {Number}   index    Leaf index to prove
+ * @param {Function} [callback] (err, { proof: Array, rootHex: String })
+ *   proof is Array<{ hex: String, side: 'left'|'right' }>
+ * @return {Q.Promise}
+ */
+Q.exports(function (Q, _) {
+
+    return Q.promisify(function (leaves, index, callback) {
+        if (index < 0 || index >= leaves.length) {
+            return callback(new Error('Q.Data.Merkle.proof: index out of range'));
+        }
+
+        var enc = new TextEncoder();
+
+        Promise.all(leaves.map(function (leaf) {
+            var bytes = (typeof leaf === 'string') ? enc.encode(leaf) : leaf;
+            return _.sha256(bytes);
+        })).then(function (hashes) {
+            var steps = [];
+            var idx   = index;
+
+            function _step(nodes) {
+                if (nodes.length === 1) {
+                    return Promise.resolve(_.toHex(nodes[0]));
+                }
+                var sibling, side;
+                if (idx % 2 === 0) {
+                    sibling = (idx + 1 < nodes.length) ? nodes[idx + 1] : nodes[idx];
+                    side    = 'right';
+                } else {
+                    sibling = nodes[idx - 1];
+                    side    = 'left';
+                }
+                steps.push({ hex: _.toHex(sibling), side: side });
+                idx = Math.floor(idx / 2);
+                return _.hashLevel(nodes).then(_step);
+            }
+
+            return _step(hashes).then(function (rootHex) {
+                callback(null, { proof: steps, rootHex: rootHex });
+            });
+        }).catch(callback);
+    }, false, 2);
+
+});

package/dist/methods/Q/Data/Merkle/verify.js

@@ -0,0 +1,32 @@
+/**
+ * Q.Data.Merkle.verify
+ * Verify a Merkle proof for a leaf against a known root.
+ *
+ * @param {Uint8Array|String} leaf     The leaf being verified
+ * @param {Array}  proof  Array<{ hex: String, side: 'left'|'right' }>
+ * @param {String} rootHex  Expected root as hex string
+ * @param {Function} [callback]  (err, Boolean)
+ * @return {Q.Promise<Boolean>}
+ */
+Q.exports(function (Q, _) {
+
+    return Q.promisify(function (leaf, proof, rootHex, callback) {
+        var enc   = new TextEncoder();
+        var bytes = (typeof leaf === 'string') ? enc.encode(leaf) : leaf;
+
+        _.sha256(bytes).then(function (current) {
+            return proof.reduce(function (chain, step) {
+                return chain.then(function (cur) {
+                    var sibling = Q.Data.fromHex(step.hex);
+                    var pair    = (step.side === 'left')
+                        ? _.concat(sibling, cur)
+                        : _.concat(cur, sibling);
+                    return _.sha256(pair);
+                });
+            }, Promise.resolve(current));
+        }).then(function (computedRoot) {
+            callback(null, _.toHex(computedRoot) === rootHex);
+        }).catch(callback);
+    }, false, 3);
+
+});

package/dist/methods/Q/Data/Prolly/_internal.js

@@ -0,0 +1,190 @@
+/**
+ * Shared structural helpers for Q.Data.Prolly method files.
+ * Loaded once via options.require and passed as _ to each method file.
+ *
+ * Also sets Q.Data.Prolly.defaultStore once loaded.
+ *
+ * Exports a plain object (sync).
+ */
+Q.exports(function (Q) {
+
+    // -------------------------------------------------------------------------
+    // Constants
+    // -------------------------------------------------------------------------
+
+    // Average ~16 keys per node. Boundary when SHA-256(key)[0] < 256/16 = 16.
+    var BRANCHING_FACTOR = 16;
+    var BOUNDARY_BYTE    = Math.floor(256 / BRANCHING_FACTOR); // 16
+
+    // -------------------------------------------------------------------------
+    // In-memory default store
+    // -------------------------------------------------------------------------
+
+    var _mem = {};
+    var defaultStore = {
+        get: function (hash) { return Promise.resolve(_mem[hash] || null); },
+        put: function (hash, node) { _mem[hash] = node; return Promise.resolve(); }
+    };
+
+    // -------------------------------------------------------------------------
+    // Helpers
+    // -------------------------------------------------------------------------
+
+    var _ = {
+
+        BOUNDARY_BYTE: BOUNDARY_BYTE,
+        defaultStore:  defaultStore,
+
+        /**
+         * SHA-256 arbitrary bytes. Returns Promise<Uint8Array(32)>.
+         */
+        sha256: function (payload) {
+            return Q.Data.digest('SHA-256', payload);
+        },
+
+        /**
+         * Hex-encode a Uint8Array.
+         */
+        toHex: function (bytes) {
+            return Q.Data.toHex(bytes);
+        },
+
+        /**
+         * A key is a chunk boundary when SHA-256(key)[0] < BOUNDARY_BYTE.
+         * Returns Promise<Boolean>.
+         */
+        isBoundary: function (key) {
+            return _.sha256(new TextEncoder().encode(key)).then(function (digest) {
+                return digest[0] < BOUNDARY_BYTE;
+            });
+        },
+
+        /**
+         * Sort entries by key, lexicographic.
+         */
+        sortEntries: function (entries) {
+            return entries.slice().sort(function (a, b) {
+                return a.key < b.key ? -1 : (a.key > b.key ? 1 : 0);
+            });
+        },
+
+        /**
+         * Serialise a node to JSON, SHA-256 it, return hex hash.
+         * Returns Promise<String>.
+         */
+        nodeHash: function (node) {
+            var bytes = new TextEncoder().encode(JSON.stringify(node));
+            return _.sha256(bytes).then(_.toHex);
+        },
+
+        /**
+         * Store a node and return { hash, node }.
+         */
+        storeNode: function (store, node) {
+            return _.nodeHash(node).then(function (hash) {
+                return store.put(hash, node).then(function () {
+                    return { hash: hash, node: node };
+                });
+            });
+        },
+
+        /**
+         * Build leaf nodes from sorted entries, splitting at boundary keys.
+         * Returns Promise<Array<{ hash, node }>>.
+         */
+        buildLeaves: function (entries, store) {
+            return Promise.all(entries.map(function (e) {
+                return _.isBoundary(e.key);
+            })).then(function (boundaries) {
+                var nodes   = [];
+                var current = { keys: [], values: [], isLeaf: true };
+                for (var i = 0; i < entries.length; i++) {
+                    current.keys.push(entries[i].key);
+                    current.values.push(entries[i].value);
+                    var isLast = (i === entries.length - 1);
+                    if ((boundaries[i] && current.keys.length > 1) || isLast) {
+                        nodes.push(Q.copy(current));
+                        current = { keys: [], values: [], isLeaf: true };
+                    }
+                }
+                return Promise.all(nodes.map(function (node) {
+                    return _.storeNode(store, node);
+                }));
+            });
+        },
+
+        /**
+         * Build one internal level from child { hash, node } pairs.
+         * Returns Promise<Array<{ hash, node }>>.
+         */
+        buildInternal: function (children, store) {
+            return Promise.all(children.map(function (child) {
+                var lastKey = child.node.keys[child.node.keys.length - 1];
+                return _.isBoundary(lastKey).then(function (b) {
+                    return { child: child, isBoundary: b };
+                });
+            })).then(function (items) {
+                var nodes   = [];
+                var current = { keys: [], children: [], isLeaf: false };
+                for (var i = 0; i < items.length; i++) {
+                    var lastKey = items[i].child.node.keys[items[i].child.node.keys.length - 1];
+                    current.keys.push(lastKey);
+                    current.children.push(items[i].child.hash);
+                    var isLast = (i === items.length - 1);
+                    if ((items[i].isBoundary && current.keys.length > 1) || isLast) {
+                        nodes.push(Q.copy(current));
+                        current = { keys: [], children: [], isLeaf: false };
+                    }
+                }
+                return Promise.all(nodes.map(function (node) {
+                    return _.storeNode(store, node);
+                }));
+            });
+        },
+
+        /**
+         * Reduce levels to a single root hash.
+         * Returns Promise<String>.
+         */
+        reduceLevel: function (nodes, store) {
+            if (nodes.length === 1) {
+                return Promise.resolve(nodes[0].hash);
+            }
+            return _.buildInternal(nodes, store).then(function (level) {
+                return _.reduceLevel(level, store);
+            });
+        },
+
+        /**
+         * Collect all { key, value } entries from a subtree.
+         * Returns Promise<Array<{ key, value }>>.
+         */
+        collectAll: function (hash, store) {
+            if (!hash) {
+                return Promise.resolve([]);
+            }
+            return store.get(hash).then(function (node) {
+                if (!node) {
+                    return [];
+                }
+                if (node.isLeaf) {
+                    return node.keys.map(function (k, i) {
+                        return { key: k, value: node.values[i] };
+                    });
+                }
+                return Promise.all(node.children.map(function (childHash) {
+                    return _.collectAll(childHash, store);
+                })).then(function (sets) {
+                    return [].concat.apply([], sets);
+                });
+            });
+        }
+
+    };
+
+    // Expose defaultStore on Q.Data.Prolly once this is loaded
+    Q.Data.Prolly.defaultStore = defaultStore;
+
+    return _;
+
+});

package/dist/methods/Q/Data/Prolly/build.js

@@ -0,0 +1,28 @@
+/**
+ * Q.Data.Prolly.build
+ * Build a Prolly tree from an array of { key, value } entries.
+ * Entries are sorted by key before insertion.
+ * Returns the root hash as a hex string.
+ *
+ * @param {Array}    entries    [{ key: String, value: String }]
+ * @param {Object}   [store]    { get(hash), put(hash, node) } -> Promise
+ * @param {Function} [callback] (err, rootHex)
+ * @return {Q.Promise<String>}
+ */
+Q.exports(function (Q, _) {
+
+    return Q.promisify(function (entries, store, callback) {
+        if (typeof store === 'function') { callback = store; store = null; }
+        store = store || _.defaultStore;
+
+        if (!entries || !entries.length) {
+            return callback(new Error('Q.Data.Prolly.build: no entries provided'));
+        }
+
+        _.buildLeaves(_.sortEntries(entries), store)
+            .then(function (level) { return _.reduceLevel(level, store); })
+            .then(function (rootHash) { callback(null, rootHash); })
+            .catch(callback);
+    }, false, 2);
+
+});

package/dist/methods/Q/Data/Prolly/delete.js

@@ -0,0 +1,28 @@
+/**
+ * Q.Data.Prolly.delete
+ * Remove a key. Returns new root hash, or null for an empty tree.
+ *
+ * @param {String}   rootHash
+ * @param {String}   key
+ * @param {Object}   [store]
+ * @param {Function} [callback]  (err, newRootHash|null)
+ * @return {Q.Promise<String|null>}
+ */
+Q.exports(function (Q, _) {
+
+    return Q.promisify(function (rootHash, key, store, callback) {
+        if (typeof store === 'function') { callback = store; store = null; }
+        store = store || _.defaultStore;
+
+        _.collectAll(rootHash, store).then(function (entries) {
+            var filtered = entries.filter(function (e) { return e.key !== key; });
+            if (!filtered.length) {
+                return Promise.resolve(null);
+            }
+            return Q.Data.Prolly.build(filtered, store);
+        }).then(function (newRootHash) {
+            callback(null, newRootHash);
+        }).catch(callback);
+    }, false, 3);
+
+});

package/dist/methods/Q/Data/Prolly/diff.js

@@ -0,0 +1,70 @@
+/**
+ * Q.Data.Prolly.diff
+ * Compute the diff between two trees.
+ * Subtrees with equal hashes are skipped entirely (structural sharing).
+ * Returns [{ key, before: value|null, after: value|null }] sorted by key.
+ *
+ * @param {String}   rootHashA  "Before" tree
+ * @param {String}   rootHashB  "After"  tree
+ * @param {Object}   [store]
+ * @param {Function} [callback]  (err, Array)
+ * @return {Q.Promise}
+ */
+Q.exports(function (Q, _) {
+
+    return Q.promisify(function (rootHashA, rootHashB, store, callback) {
+        if (typeof store === 'function') { callback = store; store = null; }
+        store = store || _.defaultStore;
+
+        var changes = [];
+
+        function _diffMaps(mapA, mapB) {
+            Object.keys(Q.extend({}, mapA, mapB)).forEach(function (k) {
+                if (mapA[k] !== mapB[k]) {
+                    changes.push({
+                        key:    k,
+                        before: mapA[k] !== undefined ? mapA[k] : null,
+                        after:  mapB[k] !== undefined ? mapB[k] : null
+                    });
+                }
+            });
+        }
+
+        function _compare(hashA, hashB) {
+            if (hashA === hashB) { return Promise.resolve(); }
+
+            return Promise.all([
+                hashA ? store.get(hashA) : Promise.resolve(null),
+                hashB ? store.get(hashB) : Promise.resolve(null)
+            ]).then(function (nodes) {
+                var nodeA = nodes[0];
+                var nodeB = nodes[1];
+
+                if ((!nodeA || nodeA.isLeaf) && (!nodeB || nodeB.isLeaf)) {
+                    var mapA = {}, mapB = {};
+                    if (nodeA) { nodeA.keys.forEach(function (k, i) { mapA[k] = nodeA.values[i]; }); }
+                    if (nodeB) { nodeB.keys.forEach(function (k, i) { mapB[k] = nodeB.values[i]; }); }
+                    _diffMaps(mapA, mapB);
+                    return;
+                }
+
+                // Mixed levels or both internal — fall back to full leaf collection
+                return Promise.all([
+                    _.collectAll(hashA, store),
+                    _.collectAll(hashB, store)
+                ]).then(function (sets) {
+                    var mapA = {}, mapB = {};
+                    sets[0].forEach(function (e) { mapA[e.key] = e.value; });
+                    sets[1].forEach(function (e) { mapB[e.key] = e.value; });
+                    _diffMaps(mapA, mapB);
+                });
+            });
+        }
+
+        _compare(rootHashA, rootHashB).then(function () {
+            changes.sort(function (a, b) { return a.key < b.key ? -1 : 1; });
+            callback(null, changes);
+        }).catch(callback);
+    }, false, 3);
+
+});

package/dist/methods/Q/Data/Prolly/get.js

@@ -0,0 +1,38 @@
+/**
+ * Q.Data.Prolly.get
+ * Look up a key in the tree. Returns value string or null if not found.
+ *
+ * @param {String}   rootHash
+ * @param {String}   key
+ * @param {Object}   [store]
+ * @param {Function} [callback]  (err, String|null)
+ * @return {Q.Promise<String|null>}
+ */
+Q.exports(function (Q, _) {
+
+    return Q.promisify(function (rootHash, key, store, callback) {
+        if (typeof store === 'function') { callback = store; store = null; }
+        store = store || _.defaultStore;
+
+        function _search(hash) {
+            return store.get(hash).then(function (node) {
+                if (!node) { return null; }
+                if (node.isLeaf) {
+                    var idx = node.keys.indexOf(key);
+                    return idx >= 0 ? node.values[idx] : null;
+                }
+                // First separator key >= search key -> descend into that child
+                var childIdx = node.keys.length - 1;
+                for (var i = 0; i < node.keys.length; i++) {
+                    if (key <= node.keys[i]) { childIdx = i; break; }
+                }
+                return _search(node.children[childIdx]);
+            });
+        }
+
+        _search(rootHash)
+            .then(function (value) { callback(null, value); })
+            .catch(callback);
+    }, false, 3);
+
+});

package/dist/methods/Q/Data/Prolly/set.js

@@ -0,0 +1,32 @@
+/**
+ * Q.Data.Prolly.set
+ * Insert or update a key-value pair. Returns new root hash.
+ * v1: full rebuild. TODO v2: path-only O(log n).
+ *
+ * @param {String}   rootHash
+ * @param {String}   key
+ * @param {String}   value
+ * @param {Object}   [store]
+ * @param {Function} [callback]  (err, newRootHash)
+ * @return {Q.Promise<String>}
+ */
+Q.exports(function (Q, _) {
+
+    return Q.promisify(function (rootHash, key, value, store, callback) {
+        if (typeof store === 'function') { callback = store; store = null; }
+        store = store || _.defaultStore;
+
+        _.collectAll(rootHash, store).then(function (entries) {
+            var found   = false;
+            var updated = entries.map(function (e) {
+                if (e.key === key) { found = true; return { key: key, value: value }; }
+                return e;
+            });
+            if (!found) { updated.push({ key: key, value: value }); }
+            return Q.Data.Prolly.build(updated, store);
+        }).then(function (newRootHash) {
+            callback(null, newRootHash);
+        }).catch(callback);
+    }, false, 4);
+
+});

package/dist/methods/Q/Data/compress.js

@@ -0,0 +1,45 @@
+Q.exports(function (Q) {
+    /**
+     * Q plugin's front end code
+     *
+     * @module Q
+     * @class Q.Data
+     */
+
+    /**
+     * Compress data with an algorithm.
+     * If the data is not a string, then it's stringified as JSON
+     * and mimeType is set as application/json.
+     * Use it like this: Q.Data.compress(data).then(Q.Data.toBase64);
+     * @static
+     * @method compress
+     * @param {String} data
+     * @param {Function} callback
+     * @param {Object} options
+     * @param {String} [options.algorithm='gzip']
+     * @param {String} [options.mimeType] If data was not a string, then it's encoded with
+     * @return {Q.Promise} that resolves to an ArrayBuffer
+     */
+    return function Q_Data_compress(data, callback, options) {
+        var algorithm = (options && options.algorithm) || 'gzip';
+        var mimeType = (options && options.mimeType);	
+        return new Q.Promise(function (res) {
+            if (typeof data !== 'string') {
+                data = JSON.stringify(data);
+                mimeType = 'application/json';
+            }
+            var stream = new Blob([data], {type: mimeType}).stream();
+            var compressedReadableStream = stream.pipeThrough(
+                new CompressionStream(algorithm)
+            );
+            var compressedResponse = new Response(compressedReadableStream);
+            compressedResponse.blob().then(function (blob) {
+                return blob.arrayBuffer();
+            }).then(function (buffer) {
+                callback && callback(buffer);
+                res(buffer);
+            });
+        });
+    };
+
+});

package/dist/methods/Q/Data/decompress.js

@@ -0,0 +1,35 @@
+Q.exports(function (Q) {
+    /**
+     * Q plugin's front end code
+     *
+     * @module Q
+     * @class Q.Data
+     */
+
+    /**
+     * Uncompress a blob that was compressed with an algorithm.
+     * @static
+     * @method decompress
+     * @param {ArrayBuffer} buffer
+     * @param {Function} callback
+     * @param {Object} options
+     * @param {String} [options.algorithm='gzip']
+     * @return {Q.Promise}
+     */
+    return function Q_Data_decompress(buffer, callback, options) {
+        var algorithm = (options && options.algorithm) || 'gzip';
+        return new Q.Promise(function (res) {
+            var ds = new DecompressionStream(algorithm);
+            var blob = new Blob([buffer]);
+            var decompressedStream = blob.stream().pipeThrough(ds);
+            var decompressedResponse = new Response(decompressedStream);
+            decompressedResponse.blob().then(function (blob) {
+                return blob.text();
+            }).then(function (text) {
+                callback && callback(text);
+                res(text);
+            });
+        });
+    };
+
+});