binary-structures-values 0.1.0

package/dist/cjs/data-stream-reader.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataStreamReader = void 0;
+const bit_stream_reader_1 = require("./bit-stream-reader");
+const schema_structure_1 = require("./schema-structure");
+const compiler_old_1 = require("./compiler-old");
+class DataStreamReader extends bit_stream_reader_1.BitStreamReader {
+    constructor(schema_or_data, data_or_complete, isComplete) {
+        let initialData;
+        let schema;
+        if (schema_or_data) {
+            if (schema_or_data instanceof Uint8Array) {
+                initialData = schema_or_data;
+                isComplete = !!data_or_complete;
+            }
+            else {
+                if (typeof schema_or_data == 'string')
+                    [schema] = (0, schema_structure_1.decodeSchemaString)(schema_or_data);
+                else
+                    [schema] = (0, schema_structure_1.decodeSchemaString)((0, schema_structure_1.encodeSchema)(schema_or_data));
+                if (data_or_complete) {
+                    if (data_or_complete instanceof Uint8Array) {
+                        initialData = data_or_complete;
+                        isComplete = !!isComplete;
+                    }
+                }
+            }
+        }
+        super(initialData, isComplete);
+        this.schema = this.schema ?? schema;
+    }
+    static compile(schema) {
+        return (0, compiler_old_1.compileReader)(schema);
+    }
+    readCompiled(compiledFn) {
+        return compiledFn(this);
+    }
+    addData(data) {
+        super.addData(data);
+        if (this.metaData === undefined && this.canReadString())
+            this.metaData = this.readString();
+        let schemaString;
+        if (!this.schema && this.canReadString() && (schemaString = this.readString())) {
+            const [schema, meta] = (0, schema_structure_1.decodeSchemaString)(schemaString);
+            this.schema = schema;
+            this.metaData = this.metaData || meta;
+        }
+    }
+    isReadyToRead() {
+        return this.metaData !== undefined && !!this.schema;
+    }
+    // if not enough bytes available to read, throws error if isComplete otherwise returns null
+    read() {
+        if (!this.schema)
+            throw new Error('Schema not found');
+        if (this.getAvailableBits() <= 0)
+            return null;
+        const savedPosition = this.bitPosition;
+        try {
+            return this.readObject(this.schema);
+        }
+        catch (e) {
+            this.bitPosition = savedPosition;
+            if (!this.isDataComplete()) {
+                return null;
+            }
+            throw e;
+        }
+    }
+    readObject(schema) {
+        const result = {};
+        for (const key of Object.keys(schema)) {
+            const def = schema[key];
+            const isOptional = ('optional' in def && def.optional) || ('types' in def &&
+                typeof def.types[0] === 'object' && 'optional' in def.types[0] && def.types[0].optional);
+            if (isOptional && !this.readBit()) {
+                if ('default' in def && def.default !== undefined)
+                    result[key] = def.default;
+                else if ('types' in def && typeof def.types[0] === 'object' && 'default' in def.types[0] && def.types[0].default !== undefined)
+                    result[key] = def.types[0].default;
+                continue;
+            }
+            result[key] = 'types' in def ? this.readMultiType(def) : this.readSingleType(def);
+        }
+        return result;
+    }
+    readSingleType(def) {
+        if (def.type === 'null')
+            return null;
+        if (def.type === 'boolean')
+            return this.readBit();
+        if (def.type === 'string')
+            return this.readString();
+        if (def.type === 'int-8')
+            return this.readInt8();
+        if (def.type === 'int-16')
+            return this.readInt16();
+        if (def.type === 'int-32')
+            return this.readInt32();
+        if (def.type === 'bigint')
+            return this.readBigInt();
+        if (def.type === 'float-32')
+            return this.readFloat32();
+        if (def.type === 'float-64')
+            return this.readFloat64();
+        if (def.type === 'array')
+            return this.readArray(def.items);
+        if (def.type === 'object')
+            return this.readObject(def.items);
+        throw new Error(`Invalid type: ${def.type}`);
+    }
+    readMultiType(def) {
+        const noOfDefs = def.types.length;
+        const minBits = Math.ceil(Math.log2(noOfDefs));
+        const bits = this.readBits(minBits);
+        const typeIndex = bits.reduce((acc, bit, i) => acc | (bit ? 1 << i : 0), 0);
+        let selectedDef = def.types[typeIndex];
+        if (typeof selectedDef === 'string')
+            selectedDef = { type: selectedDef };
+        return this.readSingleType(selectedDef);
+    }
+    readArray(itemDef) {
+        const length = this.readInt32();
+        const items = [];
+        for (let i = 0; i < length; i++) {
+            const item = 'types' in itemDef ? this.readMultiType(itemDef) : this.readSingleType(itemDef);
+            items.push(item);
+        }
+        return items;
+    }
+}
+exports.DataStreamReader = DataStreamReader;

package/dist/cjs/data-stream-writer.d.ts

@@ -0,0 +1,22 @@
+import { BitStreamWriter } from "./bit-stream-writer";
+import { DataType, DataTypeValue, DataValue, MultiType, NonOptionalSingleType, SchemaBase, SingleType } from "./schema-structure";
+export declare class DataStreamWriter extends BitStreamWriter {
+    protected readonly schema: SchemaBase;
+    protected readonly schemaString: string;
+    constructor(schema: SchemaBase, includeSchemaInData: boolean, metaData?: string);
+    static compile(schema: SchemaBase): string;
+    writeCompiled(compiledFn: (writer: DataStreamWriter, data: any) => void, data: any): void;
+    intToBits(int: number, bitCount: number): (0 | 1)[];
+    protected writeArray(value: DataTypeValue[], def: {
+        type: "array";
+        items: DataType;
+        optional?: boolean;
+    } | ({
+        type: "array";
+        items: DataType;
+    })): void;
+    protected writeSingleType(value: DataTypeValue, def: NonOptionalSingleType | SingleType): void;
+    protected writeMultiType(value: DataTypeValue, def: MultiType): void;
+    protected writeObject(data: DataValue, schema: SchemaBase): void;
+    write<D extends DataValue>(data: D): void;
+}

package/dist/cjs/data-stream-writer.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataStreamWriter = void 0;
+const bit_stream_writer_1 = require("./bit-stream-writer");
+const schema_structure_1 = require("./schema-structure");
+const compiler_old_1 = require("./compiler-old");
+// int8
+const INT8_MIN = Math.floor(-0xFF / 2);
+const INT8_MAX = Math.floor(0xFF / 2);
+// int16
+const INT16_MIN = Math.floor(-0xFFFF / 2);
+const INT16_MAX = Math.floor(0xFFFF / 2);
+// int32
+const INT32_MIN = Math.floor(-0xFFFFFFFF / 2);
+const INT32_MAX = Math.floor(0xFFFFFFFF / 2);
+class DataStreamWriter extends bit_stream_writer_1.BitStreamWriter {
+    constructor(schema, includeSchemaInData, metaData = '') {
+        super();
+        this.schemaString = (0, schema_structure_1.encodeSchema)(schema);
+        this.writeString(metaData);
+        if (includeSchemaInData)
+            this.writeString(this.schemaString);
+        else
+            this.writeString('');
+        this.schema = (0, schema_structure_1.decodeSchemaString)(this.schemaString)[0];
+    }
+    static compile(schema) {
+        return (0, compiler_old_1.compileWriter)(schema);
+    }
+    writeCompiled(compiledFn, data) {
+        compiledFn(this, data);
+    }
+    intToBits(int, bitCount) {
+        // TODO: in stead directly write in loop
+        const bits = [];
+        for (let i = 0; i < bitCount; i++) {
+            bits.push((int & (1 << i)) !== 0 ? 1 : 0);
+        }
+        return bits;
+    }
+    writeArray(value, def) {
+        const itemDef = def.items;
+        this.writeInt32(value.length);
+        if ('types' in itemDef) {
+            for (let i = 0; i < value.length; i++)
+                this.writeMultiType(value[i], itemDef);
+        }
+        else {
+            for (let i = 0; i < value.length; i++)
+                this.writeSingleType(value[i], itemDef);
+        }
+    }
+    writeSingleType(value, def) {
+        if (def.type === 'null' && value === null)
+            return;
+        if (def.type === 'boolean' && typeof value === 'boolean')
+            return this.writeBit(value ? 1 : 0);
+        if (def.type === 'string' && typeof value === 'string')
+            return this.writeString(value);
+        if (def.type === 'int-8' && typeof value === 'number')
+            return this.writeInt8(value);
+        if (def.type === 'int-16' && typeof value === 'number')
+            return this.writeInt16(value);
+        if (def.type === 'int-32' && typeof value === 'number')
+            return this.writeInt32(value);
+        if (def.type === 'bigint' && typeof value === 'bigint')
+            return this.writeBigInt(value);
+        if (def.type === 'float-32' && typeof value === 'number')
+            return this.writeFloat32(value);
+        if (def.type === 'float-64' && typeof value === 'number')
+            return this.writeFloat64(value);
+        if (def.type === 'array' && value !== null && typeof value === 'object' && Array.isArray(value))
+            return this.writeArray(value, def);
+        if (def.type === 'object' && value !== null && typeof value === 'object' && !Array.isArray(value))
+            return this.writeObject(value, def.items);
+        throw new Error(`Invalid type: ${def.type}, Value: ${value}`);
+    }
+    writeMultiType(value, def) {
+        let matchedTypes = [];
+        const noOfDefs = def.types.length;
+        const allTypes = def.types.map(t => typeof t === 'string' ? { type: t } : t);
+        // calculate min bits required to store type index
+        const minBits = Math.ceil(Math.log2(noOfDefs));
+        for (let i = 0; i < noOfDefs; i++) {
+            let typeDef = allTypes[i];
+            if (typeDef.type === 'null' && value === null)
+                matchedTypes.push(i);
+            else if (typeDef.type === 'boolean' && typeof value === 'boolean')
+                matchedTypes.push(i);
+            else if (typeDef.type === 'string' && typeof value === 'string')
+                matchedTypes.push(i);
+            else if (typeDef.type === 'int-8' && typeof value === 'number' && value % 1 === 0 && value >= INT8_MIN && value <= INT8_MAX)
+                matchedTypes.push(i);
+            else if (typeDef.type === 'int-16' && typeof value === 'number' && value % 1 === 0 && value >= INT16_MIN && value <= INT16_MAX)
+                matchedTypes.push(i);
+            else if (typeDef.type === 'int-32' && typeof value === 'number' && value % 1 === 0 && value >= INT32_MIN && value <= INT32_MAX)
+                matchedTypes.push(i);
+            else if (typeDef.type === 'bigint' && typeof value === 'bigint')
+                matchedTypes.push(i);
+            else if (typeDef.type === 'float-32' && typeof value === 'number' && Math.abs(value) <= 3.4028235e38)
+                matchedTypes.push(i);
+            else if (typeDef.type === 'float-64' && typeof value === 'number')
+                matchedTypes.push(i);
+            else if (typeDef.type === 'array' && value !== null && typeof value === 'object' && Array.isArray(value))
+                matchedTypes.push(i);
+            else if (typeDef.type === 'object' && value !== null && typeof value === 'object') {
+                const allKeys = Object.keys(typeDef.items);
+                const optionalKeys = allKeys.filter(key => {
+                    const itemDef = typeDef.items[key];
+                    return ('optional' in itemDef && itemDef.optional) || ('types' in itemDef &&
+                        typeof itemDef.types[0] === 'object' && 'optional' in itemDef.types[0] && itemDef.types[0].optional);
+                });
+                const requiredKeys = allKeys.filter(key => {
+                    const itemDef = typeDef.items[key];
+                    return !(('optional' in itemDef && itemDef.optional) || ('types' in itemDef &&
+                        typeof itemDef.types[0] === 'object' && 'optional' in itemDef.types[0] && itemDef.types[0].optional));
+                });
+                const valueKeys = Object.keys(value);
+                // 1. has all required keys
+                if (!requiredKeys.every(key => valueKeys.includes(key)))
+                    continue;
+                const remainingValueKeys = valueKeys.filter(key => !requiredKeys.includes(key));
+                //  2. The remaining keys are in optional (no extra key allowed)
+                if (!remainingValueKeys.every(key => optionalKeys.includes(key)))
+                    continue;
+                matchedTypes.push(i);
+            }
+        }
+        if (matchedTypes.length > 1) {
+            if (typeof value === "number") {
+                //  use the least number of bytes when available
+                if (matchedTypes.some(i => allTypes[i].type === 'int-8'))
+                    matchedTypes = matchedTypes.filter(i => allTypes[i].type === 'int-8');
+                else if (matchedTypes.some(i => allTypes[i].type === 'int-16'))
+                    matchedTypes = matchedTypes.filter(i => allTypes[i].type === 'int-16');
+                else if (matchedTypes.some(i => allTypes[i].type === 'int-32'))
+                    matchedTypes = matchedTypes.filter(i => allTypes[i].type === 'int-32');
+                else if (matchedTypes.some(i => allTypes[i].type === 'float-32'))
+                    matchedTypes = matchedTypes.filter(i => allTypes[i].type === 'float-32');
+            }
+        }
+        if (matchedTypes.length === 0)
+            throw new Error(`No matching type found for value: ${value}, possibles: ${allTypes.map(a => a.type)}`);
+        if (matchedTypes.length > 1)
+            throw new Error(`Multiple matching types found for value: ${value}, types: ${matchedTypes.map(i => {
+                return allTypes[i].type;
+            }).join(', ')}`);
+        this.writeBits(this.intToBits(matchedTypes[0], minBits));
+        let selectedDef = allTypes[matchedTypes[0]];
+        return this.writeSingleType(value, selectedDef);
+    }
+    writeObject(data, schema) {
+        const keys = Object.keys(schema);
+        for (const key of keys) {
+            let def = schema[key];
+            const isOptional = ('optional' in def && def.optional) || ('types' in def &&
+                typeof def.types[0] === 'object' && 'optional' in def.types[0] && def.types[0].optional);
+            if (!(key in data)) {
+                if (isOptional) {
+                    this.writeBit(0);
+                    continue;
+                }
+                throw new Error(`Missing key: ${key}`);
+            }
+            if (isOptional) {
+                this.writeBit(1);
+            }
+            const value = data[key];
+            if ('types' in def)
+                this.writeMultiType(value, def);
+            else
+                this.writeSingleType(value, def);
+        }
+    }
+    write(data) {
+        this.writeObject(data, this.schema);
+    }
+}
+exports.DataStreamWriter = DataStreamWriter;

package/dist/cjs/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./schema-structure";
+export * from "./data-stream-writer";
+export * from "./data-stream-reader";
+export * from "./bit-stream-reader";
+export * from "./bit-stream-writer";

package/dist/cjs/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./schema-structure"), exports);
+__exportStar(require("./data-stream-writer"), exports);
+__exportStar(require("./data-stream-reader"), exports);
+__exportStar(require("./bit-stream-reader"), exports);
+__exportStar(require("./bit-stream-writer"), exports);

package/dist/cjs/schema-structure.d.ts

@@ -0,0 +1,54 @@
+type CreateSingleType<T extends string, V> = ({
+    optional: true;
+    default?: V;
+} | {
+    optional?: false;
+    default?: never;
+}) & ({
+    type: T;
+});
+type AllSingleTypes = CreateSingleType<'string', string> | CreateSingleType<`int-${8 | 16 | 32}`, number> | CreateSingleType<'bigint', bigint> | CreateSingleType<`float-${32 | 64}`, number> | CreateSingleType<'boolean', boolean>;
+export type SingleType = AllSingleTypes | ({
+    type: 'null';
+    optional?: boolean;
+    default?: never;
+}) | ({
+    type: 'object';
+    items: SchemaBase;
+    optional?: boolean;
+}) | ({
+    type: 'array';
+    items: DataType;
+    optional?: boolean;
+});
+export type AllTypes = 'null' | 'string' | `int-${8 | 16 | 32}` | `float-${32 | 64}` | 'boolean' | 'bigint' | 'object' | 'array';
+export type SimpleTypes = 'null' | 'string' | `int-${8 | 16 | 32}` | `float-${32 | 64}` | 'boolean' | 'bigint';
+export type NonOptionalSingleType = ({
+    type: 'null';
+} | {
+    type: 'string' | `int-${8 | 16 | 32}` | `float-${32 | 64}` | 'boolean' | 'bigint';
+} | {
+    type: 'object';
+    items: SchemaBase;
+} | {
+    type: 'array';
+    items: DataType;
+}) & ({
+    optional?: never;
+    default?: never;
+});
+export type MultiType = {
+    types: [SingleType, ...Array<NonOptionalSingleType>] | [SimpleTypes, ...SimpleTypes[]];
+};
+export type DataType = SingleType | MultiType;
+export type SchemaBase = Record<string, DataType>;
+export type DataTypeValue = string | number | bigint | boolean | null | {
+    [key: string]: DataTypeValue;
+} | DataTypeValue[];
+export type DataValue = {
+    [key: string]: DataTypeValue;
+};
+export declare const createSchema: <S extends SchemaBase>(schema: S) => S;
+export declare const encodeSchema: <S extends SchemaBase>(schema: S) => string;
+export declare const decodeSchemaString: <S extends SchemaBase = SchemaBase>(schemaString: string) => [schema: S, metadata: string];
+export {};