@itee/client 10.0.0

package/sources/loaders/converters/ArrayBinaryConverter.js

@@ -0,0 +1,33 @@
+import { TBinaryConverter } from '../TBinaryConverter.js'
+
+// import { DefaultBinarySerializer } from '../TBinarySerializer'
+
+class ArrayBinaryConverter extends TBinaryConverter {
+    constructor( serializer ) { super( Array, serializer ) }
+
+    to( writer, instance, options = {} ) {
+
+        const numberOfElements = instance.length
+        writer.setUint32( numberOfElements )
+        for ( let instanceElement of instance ) {
+            //            DefaultBinarySerializer._serialize( instanceElement )
+            this.serializer._serialize( instanceElement )
+        }
+
+    }
+    from( reader, options = {} ) {
+
+        const numberOfElements = reader.getUint32()
+        const result           = []
+        for ( let i = 0 ; i < numberOfElements ; i++ ) {
+            //            const element = DefaultBinarySerializer._deserialize()
+            const element = this.serializer._deserialize()
+            result.push( element )
+        }
+
+        return result
+
+    }
+}
+
+export { ArrayBinaryConverter }

package/sources/loaders/converters/BooleanBinaryConverter.js

@@ -0,0 +1,24 @@
+/**
+ * @author [Tristan Valcke]{@link https://github.com/Itee}
+ * @license [BSD-3-Clause]{@link https://opensource.org/licenses/BSD-3-Clause}
+ */
+import { TBinaryConverter } from '../TBinaryConverter.js'
+
+class BooleanBinaryConverter extends TBinaryConverter {
+
+    constructor( serializer ) { super( Boolean, serializer ) }
+
+    to( writer, instance, options = {} ) {
+
+        writer.setBoolean( instance )
+
+    }
+
+    from( reader, options = {} ) {
+
+        return reader.getBoolean()
+
+    }
+}
+
+export { BooleanBinaryConverter }

package/sources/loaders/converters/DateBinaryConverter.js

@@ -0,0 +1,21 @@
+import { TBinaryConverter } from '../TBinaryConverter.js'
+
+// import { DefaultBinarySerializer } from '../TBinarySerializer'
+
+class DateBinaryConverter extends TBinaryConverter {
+    constructor( serializer ) { super( Date, serializer ) }
+
+    to( writer, instance, options = {} ) {
+        const utc = instance.toUTCString()
+        this.serializer._serialize( utc )
+//        DefaultBinarySerializer._serialize( utc )
+    }
+
+    from( reader, options = {} ) {
+        const utcString = this.serializer._deserialize()
+//        const utcString = DefaultBinarySerializer._deserialize()
+        return new Date( utcString )
+    }
+}
+
+export { DateBinaryConverter }

package/sources/loaders/converters/NullBinaryConverter.js

@@ -0,0 +1,13 @@
+import { TBinaryConverter } from '../TBinaryConverter.js'
+
+class NullBinaryConverter extends TBinaryConverter {
+    constructor( serializer ) { super( null, serializer ) }
+
+    to( writer, instance, options = {} ) {}
+
+    from( reader, options = {} ) {
+        return null
+    }
+}
+
+export { NullBinaryConverter }

package/sources/loaders/converters/NumberBinaryConverter.js

@@ -0,0 +1,15 @@
+import { TBinaryConverter } from '../TBinaryConverter.js'
+
+class NumberBinaryConverter extends TBinaryConverter {
+    constructor( serializer ) { super( Number, serializer ) }
+
+    to( writer, instance, options = {} ) {
+        writer.setFloat64( instance )
+    }
+
+    from( reader, options = {} ) {
+        return reader.getFloat64()
+    }
+}
+
+export { NumberBinaryConverter }

package/sources/loaders/converters/ObjectBinaryConverter.js

@@ -0,0 +1,101 @@
+import { TBinaryConverter } from '../TBinaryConverter.js'
+
+// import { DefaultBinarySerializer } from '../TBinarySerializer'
+
+class ObjectBinaryConverter extends TBinaryConverter {
+    constructor( subType, serializer ) { super( subType || Object, serializer ) }
+
+    to( writer, instance, options = {} ) {
+
+        // Keep only writable properties from instance
+        // Read-only property are considered as it ! And won't be serialized.
+        const descriptors             = Object.getOwnPropertyDescriptors( instance )
+        const writablePropertyEntries = Object.values( descriptors )
+                                              .filter( ( value ) => value.writable && value.enumerable )
+
+        // Store number of writable properties of object for future deserialization loop
+        writer.setUint8( writablePropertyEntries.length )
+
+        for ( let [ key, property ] of writablePropertyEntries ) {
+            //            console.log( key, property.value )
+
+            writer.setUint32( key.length )
+            writer.setString( key )
+
+            // target private method to allow buffer clipping on serialization
+            this.serializer._serialize( property.value )
+//            DefaultBinarySerializer._serialize( property.value )
+        }
+
+        //        const instanceKeys = Object.keys( instance )
+        //        console.log( instanceKeys )
+        //
+        //        const instanceEntries = Object.entries( instance )
+        //        console.log( instanceEntries )
+        //
+        //        const descriptors = Object.getOwnPropertyDescriptors( instance )
+        //        for ( let descriptor in descriptors ) {
+        //            if ( !instanceKeys.includes( descriptor ) ) { continue }
+        //
+        //
+        //            if ( !descriptor.writable ) { continue }
+        //
+        //
+        //        }
+        //
+        //        const descKeys = Object.keys( descriptors )
+        //        console.log( descKeys )
+        //
+        //        const descEntries = Object.entries( descriptors )
+        //        console.log( descEntries )
+        //
+        //        const filteredVals = Object.values( descriptors )
+        //                                   .filter( value => value.writable )
+        //        console.log( filteredVals )
+        //
+        //        const filtered = descEntries.filter( ( [ key, value ] ) => value.writable && value.enumerable )
+        //        console.log( filtered )
+
+        // Store number of object keys for deserialization loop
+        //        const keys = Object.keys( instance )
+        //        writer.setUint8( keys.length )
+        //
+        //        for ( let key of keys ) {
+        //            if ( !instance.hasOwnProperty( key ) ) { continue }
+        //
+        //            writer.setUint32( key.length )
+        //            writer.setString( key )
+        //
+        //            TBinarySerializer.serialize( instance[ key ] )
+        //        }
+
+    }
+
+    from( reader, options = {} ) {
+        const instance = super.from( reader, options )
+
+
+        //        const descriptors        = Object.getOwnPropertyDescriptors( instance )
+        //        const result             = {}
+        const numberOfProperties = reader.getUint8()
+        for ( let i = 0 ; i < numberOfProperties ; i++ ) {
+            const keyLength = reader.getUint32()
+            const keyName   = reader.getString( keyLength )
+
+            instance[ keyName ] = this.serializer._deserialize()
+//            instance[ keyName ] = DefaultBinarySerializer._deserialize()
+            //
+            //            const descriptor = descriptors[ keyName ]
+            //
+            //            if ( descriptor.writable ) {
+            //                instance[ keyName ] = TBinarySerializer._deserialize()
+            //            } else {
+            //                var deseri = TBinarySerializer._deserialize()
+            //            }
+        }
+        return instance
+
+    }
+}
+
+export { ObjectBinaryConverter }

package/sources/loaders/converters/RegExBinaryConverter.js

@@ -0,0 +1,11 @@
+import { TBinaryConverter } from '../TBinaryConverter.js'
+
+class RegExBinaryConverter extends TBinaryConverter {
+    constructor( serializer ) { super( RegExp, serializer ) }
+
+    from( reader, options = {} ) {
+        return new RegExp()
+    }
+}
+
+export { RegExBinaryConverter }

package/sources/loaders/converters/StringBinaryConverter.js

@@ -0,0 +1,26 @@
+/**
+ * @author [Tristan Valcke]{@link https://github.com/Itee}
+ * @license [BSD-3-Clause]{@link https://opensource.org/licenses/BSD-3-Clause}
+ */
+import { TBinaryConverter } from '../TBinaryConverter.js'
+
+class StringBinaryConverter extends TBinaryConverter {
+
+    constructor( serializer ) { super( String, serializer ) }
+
+    to( writer, instance, options = {} ) {
+
+        writer.setUint32( instance.length )
+        writer.setString( instance )
+
+    }
+
+    from( reader, options = {} ) {
+
+        const stringLength = reader.getUint32()
+        return reader.getString( stringLength )
+
+    }
+}
+
+export { StringBinaryConverter }

package/sources/loaders/converters/UndefinedBinaryConverter.js

@@ -0,0 +1,13 @@
+import { TBinaryConverter } from '../TBinaryConverter.js'
+
+class UndefinedBinaryConverter extends TBinaryConverter {
+    constructor( serializer ) { super( null, serializer ) }
+
+    to( writer, instance, options = {} ) {}
+
+    from( reader, options = {} ) {
+        return undefined
+    }
+}
+
+export { UndefinedBinaryConverter }