@itee/client 10.0.0

package/sources/loaders/TBinarySerializer.js

@@ -0,0 +1,258 @@
+/**
+ * @author [Tristan Valcke]{@link https://github.com/Itee}
+ * @license [BSD-3-Clause]{@link https://opensource.org/licenses/BSD-3-Clause}
+ */
+
+import {
+    isArray,
+    isBoolean,
+    isNotDefined,
+    isNull,
+    isNumber,
+    isObject,
+    isString,
+    isUndefined
+}                                   from '@itee/validators'
+import { ArrayBinaryConverter }     from './converters/ArrayBinaryConverter.js'
+import { BooleanBinaryConverter }   from './converters/BooleanBinaryConverter.js'
+import { DateBinaryConverter }      from './converters/DateBinaryConverter.js'
+import { NullBinaryConverter }      from './converters/NullBinaryConverter.js'
+import { NumberBinaryConverter }    from './converters/NumberBinaryConverter.js'
+import { ObjectBinaryConverter }    from './converters/ObjectBinaryConverter.js'
+import { RegExBinaryConverter }     from './converters/RegExBinaryConverter.js'
+import { StringBinaryConverter }    from './converters/StringBinaryConverter.js'
+import { UndefinedBinaryConverter } from './converters/UndefinedBinaryConverter.js'
+import { TBinaryReader }            from './TBinaryReader.js'
+import { TBinaryWriter }            from './TBinaryWriter.js'
+
+//const BinaryType = toEnum( {
+//    Null:        0,
+//    Boolean:     1,
+//    Number:      2,
+//    String:      3,
+//    Date:        4,
+//    RegExp:      5,
+//    Object:      6,
+//    Array:       7,
+//    UserDefined: 8
+//} )
+
+const BinaryType = {
+    Null:        0,
+    Undefined:   1,
+    Boolean:     2,
+    Number:      3,
+    String:      4,
+    Date:        5,
+    RegEx:       6,
+    Array:       7,
+    Object:      8,
+    UserDefined: 255
+}
+
+function isDate( value ) {
+    if ( isNotDefined( value ) ) {
+        return false
+    }
+
+    switch ( typeof value ) {
+        case 'number':
+            return true
+        case 'string':
+            return !isNaN( Date.parse( value ) )
+        case 'object':
+            if ( value instanceof Date ) {
+                return !isNaN( value.getTime() )
+            } else {
+                return false
+            }
+        default:
+            return false
+    }
+}
+
+function isRegEx( value ) {
+    if ( isNotDefined( value ) ) {
+        return false
+    }
+
+    return value instanceof RegExp
+}
+
+class TBinarySerializer {
+
+    constructor() {
+
+        this.reader = new TBinaryReader()
+        this.writer = new TBinaryWriter()
+
+        this.converters = new Map( [
+            [ BinaryType.Null, new NullBinaryConverter( this ) ],
+            [ BinaryType.Undefined, new UndefinedBinaryConverter( this ) ],
+            [ BinaryType.Boolean, new BooleanBinaryConverter( this ) ],
+            [ BinaryType.Number, new NumberBinaryConverter( this ) ],
+            [ BinaryType.String, new StringBinaryConverter( this ) ],
+            [ BinaryType.Date, new DateBinaryConverter( this ) ],
+            [ BinaryType.RegEx, new RegExBinaryConverter( this ) ],
+            [ BinaryType.Array, new ArrayBinaryConverter( this ) ],
+            [ BinaryType.Object, new ObjectBinaryConverter( null, this ) ],
+            [ BinaryType.UserDefined, new Map( [] ) ]
+        ] )
+
+        //        this.converters.set( BinaryType.Boolean, new BooleanBinaryConverter() )
+        //        this.converters.set( 'String', new StringBinaryConverter() )
+    }
+
+    addConverter( converter ) {
+
+        converter.serializer = this
+
+        const userDefinedConverters = this.converters.get( BinaryType.UserDefined )
+        userDefinedConverters.set( converter.targetCtor.name, converter )
+
+    }
+    removeConverter( converter ) {
+        const userDefinedConverters = this.converters.get( BinaryType.UserDefined )
+        userDefinedConverters.remove( converter.targetCtor.name )
+    }
+
+    serialize( instance, options = {} ) {
+
+        // Reset writer buffer
+        this.writer.buffer = new ArrayBuffer( 1024 )
+        const buffer       = this._serialize( instance )
+
+//        // Clip buffer to current offset
+//        const writerOffset = this.writer.offset
+//        console.log( writerOffset )
+//        const clippedBuffer = buffer.slice( 0, writerOffset )
+//
+//        return clippedBuffer
+//
+
+        // Clip buffer to current writer offset
+        return buffer.slice( 0, this.writer.offset )
+    }
+    _serialize( instance ) {
+        const binaryType = this._getBinaryTypeOf( instance )
+
+        // Prepend internal binary type for deserialization process to be able to target correct converter
+        this.writer.setUint8( binaryType )
+
+        // Get local converters and in case where binary type is userdefined, search in specific converter or use default (unoptimized)
+        let converter = this.converters.get( binaryType )
+        if ( binaryType === BinaryType.UserDefined ) {
+
+            // Prepend class name for deserialization (like BinaryType for primitives)
+            const ctor     = instance.constructor
+            const ctorName = ctor.name
+            this.writer.setUint8( ctorName.length )
+            this.writer.setString( ctorName )
+
+            if ( !converter.has( ctorName ) ) {
+                console.info( `Need to create new converter for ${ ctorName } serialization. The serialization of this class could be optimized using it's own dedicated serializer that extend TBinaryConverter and add it to serializer converters.` )
+                converter.set( ctorName, new ObjectBinaryConverter( ctor, this ) )
+            }
+            converter = converter.get( ctorName )
+        }
+
+        converter.to( this.writer, instance )
+
+        return this.writer.buffer
+    }
+    _getBinaryTypeOf( instance ) {
+        let binaryType
+        if ( isNull( instance ) ) {
+            binaryType = BinaryType.Null
+        } else if ( isUndefined( instance ) ) {
+            binaryType = BinaryType.Undefined
+        } else if ( isBoolean( instance ) ) {
+            binaryType = BinaryType.Boolean
+        } else if ( isNumber( instance ) ) {
+            binaryType = BinaryType.Number
+        } else if ( isString( instance ) ) {
+            binaryType = BinaryType.String
+        } else if ( isDate( instance ) ) {
+            binaryType = BinaryType.Date
+        } else if ( isRegEx( instance ) ) {
+            binaryType = BinaryType.RegEx
+        } else if ( isArray( instance ) ) {
+            binaryType = BinaryType.Array
+        } else if ( isObject( instance ) ) { // Todo: care it should be isPlainObject !!!
+            binaryType = BinaryType.Object
+        } else { // UserDefined check in registered converters
+            binaryType = BinaryType.UserDefined
+        }
+
+        return binaryType
+    }
+
+    deserialize( buffer ) {
+        if ( isNotDefined( buffer ) || buffer.length === 0 ) { return }
+
+        // Reset writer buffer
+        this.reader.setBuffer( buffer, 0, buffer.length )
+
+        return this._deserialize()
+
+    }
+    _deserialize() {
+
+        const binaryType = this.reader.getUint8()
+
+        let converter = this.converters.get( binaryType )
+        if ( binaryType === BinaryType.UserDefined ) {
+
+            const ctorNameLength = this.reader.getUint8()
+            const ctorName       = this.reader.getString( ctorNameLength )
+
+            // var ctor = this._getCtorOf( ctorName )
+
+            converter = converter.has( ctorName )
+                        ? converter.get( ctorName )
+                        : null //converter.get( null )
+
+            // Get specific or create default converter for userdefined type
+            //            const ctorNameLength = this.reader.getUint8()
+            //            const ctorName = this.reader.getString( ctorNameLength )
+            //
+            //            if ( !converter.has( ctorName ) ) {
+            //                console.info( `Need to create new converter for ${ ctorName } serialization. The serialization of this class could be optimized using it's own dedicated serializer that extend TBinaryConverter and add it to serializer
+            // converters.` ) converter.set( ctorName, new ObjectBinaryConverter( ctor ) ) } converter = converter.get( ctorName )
+        }
+
+        if ( !converter ) {
+            throw new TypeError( `Unable to found appropriate converter for deserialize type: ${ binaryType }` )
+        }
+
+        return converter.from( this.reader )
+
+    }
+    // _getCtorOf ( typeName ) {
+    //     var stringToFunction = function ( str ) {
+    //         var arr = str.split( '.' )
+    //
+    //         var fn = ( window || this )
+    //         for ( var i = 0, len = arr.length ; i < len ; i++ ) {
+    //             fn = fn[ arr[ i ] ]
+    //         }
+    //
+    //         if ( typeof fn !== 'function' ) {
+    //             throw new Error( 'function not found' )
+    //         }
+    //
+    //         return fn
+    //     }
+    // }
+
+}
+
+const binarySerializerInstance = /*#__PURE__*/new TBinarySerializer()
+
+export {
+    isDate,
+    isRegEx,
+    binarySerializerInstance as DefaultBinarySerializer,
+    TBinarySerializer,
+    BinaryType
+}

package/sources/loaders/TBinaryWriter.js

@@ -0,0 +1,429 @@
+import {
+    isNotArrayBuffer,
+    isNotBoolean,
+    isNotNumber,
+    isNull,
+    isUndefined
+} from '@itee/validators'
+import {
+    Byte,
+    Endianness
+} from './TBinaryReader.js'
+
+/**
+ * @author [Tristan Valcke]{@link https://github.com/Itee}
+ * @license [BSD-3-Clause]{@link https://opensource.org/licenses/BSD-3-Clause}
+ */
+
+class TBinaryWriter {
+
+    constructor( {
+        buffer = new ArrayBuffer( 1024 ),
+        endianness = Endianness.Little
+    } = {} ) {
+
+        this.buffer     = buffer
+        this.endianness = endianness
+
+        // Todo: For bit writing use same approche than byte
+        //        this._bits = {
+        //            buffer: null,
+        //            offset: 0,
+        //            length: 0
+        //        }
+
+        this._updateDataView()
+    }
+    /**
+     *
+     * @returns {*}
+     */
+    get buffer() {
+        return this._buffer
+    }
+    set buffer( value ) {
+
+        const memberName = 'Buffer'
+        const expect     = 'Expect an instance of ArrayBuffer.'
+
+        if ( isNull( value ) ) { throw new TypeError( `${ memberName } cannot be null ! ${ expect }` ) }
+        if ( isUndefined( value ) ) { throw new TypeError( `${ memberName } cannot be undefined ! ${ expect }` ) }
+        if ( isNotArrayBuffer( value ) ) { throw new TypeError( `${ memberName } cannot be an instance of ${ value.constructor.name } ! ${ expect }` ) }
+
+        this._buffer = value
+        this._offset = 0
+        this._length = value.byteLength
+
+        this._updateDataView()
+
+    }
+    /**
+     *
+     * @returns {*}
+     */
+    get offset() {
+        return this._offset
+    }
+    set offset( value ) {
+
+        const memberName = 'Offset'
+        const expect     = 'Expect a number.'
+
+        if ( isNull( value ) ) { throw new TypeError( `${ memberName } cannot be null ! ${ expect }` ) }
+        if ( isUndefined( value ) ) { throw new TypeError( `${ memberName } cannot be undefined ! ${ expect }` ) }
+        if ( isNotNumber( value ) ) { throw new TypeError( `${ memberName } cannot be an instance of ${ value.constructor.name } ! ${ expect }` ) }
+
+        this._offset = value
+
+        this._updateDataView()
+
+    }
+    /**
+     *
+     * @param value
+     */
+    get length() {
+        return this._length
+    }
+    set length( value ) {
+
+        const memberName = 'Length'
+        const expect     = 'Expect a number.'
+
+        if ( isNull( value ) ) { throw new TypeError( `${ memberName } cannot be null ! ${ expect }` ) }
+        if ( isUndefined( value ) ) { throw new TypeError( `${ memberName } cannot be undefined ! ${ expect }` ) }
+        if ( isNotNumber( value ) ) { throw new TypeError( `${ memberName } cannot be an instance of ${ value.constructor.name } ! ${ expect }` ) }
+
+        this._length = value
+
+        this._updateDataView()
+
+    }
+    /**
+     *
+     * @returns {*}
+     */
+    get endianness() {
+        return this._endianness
+    }
+    set endianness( value ) {
+
+        const memberName = 'Endianness'
+        const expect     = 'Expect a boolean.'
+
+        if ( isNull( value ) ) { throw new TypeError( `${ memberName } cannot be null ! ${ expect }` ) }
+        if ( isUndefined( value ) ) { throw new TypeError( `${ memberName } cannot be undefined ! ${ expect }` ) }
+        if ( isNotBoolean( value ) ) { throw new TypeError( `${ memberName } cannot be an instance of ${ value.constructor.name } ! ${ expect }` ) }
+
+        this._endianness = value
+    }
+    /**
+     *
+     * @param buffer
+     * @param offset
+     * @param length
+     * @returns {TBinaryReader}
+     */
+    setBuffer( buffer, offset, length ) {
+
+        this.buffer = buffer
+        this.offset = offset || 0
+        this.length = length || buffer.byteLength
+
+        return this
+
+    }
+
+    /**
+     *
+     * @param value
+     * @returns {TBinaryReader}
+     */
+    setOffset( value ) {
+
+        this.offset = value
+        return this
+
+    }
+
+    /**
+     *
+     * @param value
+     * @returns {TBinaryReader}
+     */
+    setLength( value ) {
+
+        this.length = value
+        return this
+
+    }
+
+    /**
+     *
+     * @param endianess
+     * @returns {TBinaryReader}
+     */
+    setEndianess( endianess ) {
+
+        this.endianness = endianess
+        return this
+
+    }
+
+    /**
+     *
+     * @param increment
+     * @returns {*}
+     * @private
+     */
+    _getAndUpdateOffsetBy( increment ) {
+
+        const currentOffset = this._offset
+        this._offset += increment
+
+        // Manage buffer overflow, and auto-extend if needed
+        const bufferByteLength = this._buffer.byteLength
+        if ( this._offset >= bufferByteLength ) {
+
+            // Create new buffer and view with extended size
+            const newBuffer   = new ArrayBuffer( bufferByteLength + 1024 )
+            const newDataView = new DataView( newBuffer, 0, newBuffer.byteLength )
+
+            // Copy data from current to new
+            for ( let i = 0 ; i < bufferByteLength ; i++ ) {
+                newDataView.setUint8( i, this._dataView.getUint8( i ) )
+            }
+
+            // Update local
+            this._buffer   = newBuffer
+            this._dataView = newDataView
+
+        }
+
+        return currentOffset
+
+    }
+
+    /**
+     *
+     * @private
+     */
+    _updateDataView() {
+
+        this._dataView = new DataView( this._buffer, this._offset, this._length )
+
+    }
+
+    /**
+     *
+     * @returns {boolean}
+     */
+    isEndOfFile() {
+
+        return ( this._offset === this._length )
+
+    }
+
+    _iterArray( values, func, moveNext ) {
+
+        const currentOffset = this._offset
+
+        for ( let value of values ) {
+            func( value )
+        }
+
+        if ( !moveNext ) {
+            this._offset = currentOffset
+        }
+
+    }
+
+    // Bytes
+
+    /**
+     *
+     * @param offset
+     */
+    skipOffsetTo( offset ) {
+
+        this._offset = offset
+
+    }
+
+    /**
+     *
+     * @param nBytes
+     */
+    skipOffsetOf( nBytes ) {
+
+        this._offset += nBytes
+
+    }
+
+    setBoolean( value, moveNext = true ) {
+
+        this.setUint8( ( ( value & 1 ) === 1 ), moveNext )
+
+    }
+
+    setBooleanArray( values, moveNext = true ) {
+
+        this._iterArray( values, this.setBoolean.bind( this ), moveNext )
+
+    }
+
+    setInt8( value, moveNext = true ) {
+
+        const offset = ( moveNext ) ? this._getAndUpdateOffsetBy( Byte.One ) : this._offset
+        this._dataView.setInt8( offset, value )
+
+    }
+
+    setInt8Array( values, moveNext = true ) {
+
+        this._iterArray( values, this.setInt8.bind( this ), moveNext )
+
+    }
+
+    setUint8( value, moveNext = true ) {
+
+        const offset = ( moveNext ) ? this._getAndUpdateOffsetBy( Byte.One ) : this._offset
+        this._dataView.setUint8( offset, value )
+
+    }
+
+    setUint8Array( values, moveNext = true ) {
+
+        this._iterArray( values, this.setUint8.bind( this ), moveNext )
+
+    }
+
+    setInt16( value, moveNext = true ) {
+
+        const offset = ( moveNext ) ? this._getAndUpdateOffsetBy( Byte.Two ) : this._offset
+        this._dataView.setInt16( offset, value, this._endianness )
+
+    }
+
+    setInt16Array( values, moveNext = true ) {
+
+        this._iterArray( values, this.setInt16.bind( this ), moveNext )
+
+    }
+
+    setUint16( value, moveNext = true ) {
+
+        const offset = ( moveNext ) ? this._getAndUpdateOffsetBy( Byte.Two ) : this._offset
+        this._dataView.setUint16( offset, value, this._endianness )
+
+    }
+
+    setUint16Array( values, moveNext = true ) {
+
+        this._iterArray( values, this.setUint16.bind( this ), moveNext )
+
+    }
+
+    setInt32( value, moveNext = true ) {
+
+        const offset = ( moveNext ) ? this._getAndUpdateOffsetBy( Byte.Four ) : this._offset
+        this._dataView.setInt32( offset, value, this._endianness )
+
+    }
+
+    setInt32Array( values, moveNext = true ) {
+
+        this._iterArray( values, this.setInt32.bind( this ), moveNext )
+
+    }
+
+    setUint32( value, moveNext = true ) {
+
+        const offset = ( moveNext ) ? this._getAndUpdateOffsetBy( Byte.Four ) : this._offset
+        this._dataView.setUint32( offset, value, this._endianness )
+
+    }
+
+    setUint32Array( values, moveNext = true ) {
+
+        this._iterArray( values, this.setUint32.bind( this ), moveNext )
+
+    }
+
+    setInt64( /*value, moveNext = true*/ ) {
+
+        // From THREE.FBXLoader
+        // JavaScript doesn't support 64-bit integer so attempting to calculate by ourselves.
+        // 1 << 32 will return 1 so using multiply operation instead here.
+        // There'd be a possibility that this method returns wrong value if the value
+        // is out of the range between Number.MAX_SAFE_INTEGER and Number.MIN_SAFE_INTEGER.
+        // TODO: safely handle 64-bit integer using bigint ?
+
+        throw new Error( 'Not implemented, sorry... any help is welcome !' )
+    }
+
+    setInt64Array( values, moveNext = true ) {
+
+        this._iterArray( values, this.setInt64.bind( this ), moveNext )
+
+    }
+
+    setUint64( /*value, moveNext = true*/ ) {
+        // Note: see setInt64() comment
+        throw new Error( 'Not implemented, sorry... any help is welcome !' )
+    }
+
+    setUint64Array( values, moveNext = true ) {
+
+        this._iterArray( values, this.setUint64.bind( this ), moveNext )
+
+    }
+
+    setFloat32( value, moveNext = true ) {
+
+        const offset = ( moveNext ) ? this._getAndUpdateOffsetBy( Byte.Four ) : this._offset
+        this._dataView.setFloat32( offset, value, this._endianness )
+
+    }
+
+    setFloat32Array( values, moveNext = true ) {
+
+        this._iterArray( values, this.setFloat32.bind( this ), moveNext )
+
+    }
+
+    setFloat64( value, moveNext = true ) {
+
+        const offset = ( moveNext ) ? this._getAndUpdateOffsetBy( Byte.Eight ) : this._offset
+        this._dataView.setFloat64( offset, value, this._endianness )
+
+    }
+
+    setFloat64Array( values, moveNext = true ) {
+
+        this._iterArray( values, this.setFloat64.bind( this ), moveNext )
+
+    }
+
+    setChar( value, moveNext = true ) {
+
+        this.setUint8( value.charCodeAt( 0 ), moveNext )
+
+    }
+
+    setString( values, moveNext = true ) {
+
+        this._iterArray( values, this.setChar.bind( this ), moveNext )
+
+    }
+
+    //    setArrayBuffer ( value, moveNext = true ) {
+    //
+    //        const offset = this._getAndUpdateOffsetBy( size )
+    //        this._dataView.buffer.slice( offset, offset + size )
+    //
+    //    }
+
+}
+
+export { TBinaryWriter }

package/sources/loaders/_loaders.js

@@ -0,0 +1,21 @@
+/**
+ * @module Loaders
+ * @description Intermediary export file for loaders. Export [TBinaryReader]{@link TBinaryReader}, [Endianness]{@link Endianness}, and [Byte]{@link Byte}
+ *
+ * @author [Tristan Valcke]{@link https://github.com/Itee}
+ * @license [BSD-3-Clause]{@link https://opensource.org/licenses/BSD-3-Clause}
+ */
+
+export * from './TBinaryConverter.js'
+export * from './TBinaryReader.js'
+export * from './TBinarySerializer.js'
+export * from './TBinaryWriter.js'
+export * from './converters/NullBinaryConverter.js'
+export * from './converters/UndefinedBinaryConverter.js'
+export * from './converters/NumberBinaryConverter.js'
+export * from './converters/StringBinaryConverter.js'
+export * from './converters/DateBinaryConverter.js'
+export * from './converters/RegExBinaryConverter.js'
+export * from './converters/ArrayBinaryConverter.js'
+export * from './converters/ObjectBinaryConverter.js'
+