@itee/client 10.0.0

package/sources/cores/TStore.js

@@ -0,0 +1,303 @@
+import {
+    isFunction,
+    isNotArray,
+    isNotBoolean,
+    isNotObject,
+    isNotUndefined,
+    isNull,
+    isString,
+    isUndefined
+} from '@itee/validators'
+
+/**
+ * @class
+ * @classdesc TStore is a simple javascript object whose purpose is to store some ket/value data to future usage. It could be enable/disable.
+ *
+ * @example {@lang javascript}
+ * var cache = new TCache()
+ * cache.add( 'foo', 'bar' )
+ * TLogger.log( cache.get('foo') ) // 'bar'
+ *
+ * @author [Tristan Valcke]{@link https://github.com/Itee}
+ * @license [BSD-3-Clause]{@link https://opensource.org/licenses/BSD-3-Clause}
+ */
+class TStore {
+
+    /**
+     * @constructor
+     * @param {Object} [parameters={}]
+     * @param {Object} [parameters.collection={}]
+     * @param {Boolean} [parameters.allowOverride=false]
+     * @param {Array.<function>} [parameters.keyValidators=[]]
+     * @param {Array.<function>} [parameters.valueValidators=[]]
+     */
+    constructor( parameters = {} ) {
+
+        const _parameters = {
+            ...{
+                collection:      {},
+                allowOverride:   false,
+                keyValidators:   [],
+                valueValidators: []
+            }, ...parameters
+        }
+
+        this.collection      = _parameters.collection
+        this.allowOverride   = _parameters.allowOverride
+        this.keyValidators   = _parameters.keyValidators
+        this.valueValidators = _parameters.valueValidators
+
+    }
+    /**
+     *
+     * @return {{}}
+     */
+    get collection() {
+
+        return this._collection
+
+    }
+    set collection( value ) {
+
+        const memberName = 'Collection'
+        const expect     = 'Expect an object.'
+
+        if ( isNull( value ) ) { throw new TypeError( `${ memberName } cannot be null ! ${ expect }` ) }
+        if ( isUndefined( value ) ) { throw new TypeError( `${ memberName } cannot be undefined ! ${ expect }` ) }
+        if ( isNotObject( value ) ) { throw new TypeError( `${ memberName } cannot be an instance of ${ value.constructor.name } ! ${ expect }` ) }
+
+        this._collection = value
+
+    }
+    /**
+     *
+     * @return {*}
+     */
+    get allowOverride() {
+
+        return this._allowOverride
+
+    }
+    set allowOverride( value ) {
+
+        const memberName = 'Allow override'
+        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._allowOverride = value
+
+    }
+    /**
+     *
+     * @return {*}
+     */
+    get keyValidators() {
+
+        return this._keyValidators
+
+    }
+    set keyValidators( value ) {
+
+        const memberName = 'Keys validators'
+        const expect     = 'Expect an array of TValidator or an empty array.'
+
+        if ( isNull( value ) ) { throw new TypeError( `${ memberName } cannot be null ! ${ expect }` ) }
+        if ( isUndefined( value ) ) { throw new TypeError( `${ memberName } cannot be undefined ! ${ expect }` ) }
+        if ( isNotArray( value ) ) { throw new TypeError( `${ memberName } cannot be an instance of ${ value.constructor.name } ! ${ expect }` ) }
+
+        this._keyValidators = value
+
+    }
+    /**
+     *
+     * @return {*}
+     */
+    get valueValidators() {
+        return this._valueValidators
+    }
+    set valueValidators( value ) {
+
+        const memberName = 'Values validators'
+        const expect     = 'Expect an array of TValidator or an empty array.'
+
+        if ( isNull( value ) ) { throw new TypeError( `${ memberName } cannot be null ! ${ expect }` ) }
+        if ( isUndefined( value ) ) { throw new TypeError( `${ memberName } cannot be undefined ! ${ expect }` ) }
+        if ( isNotArray( value ) ) { throw new TypeError( `${ memberName } cannot be an instance of ${ value.constructor.name } ! ${ expect }` ) }
+
+        this._valueValidators = value
+
+    }
+    /**
+     *
+     * @return {string[]}
+     */
+    get keys() {
+
+        return Object.keys( this._collection )
+
+    }
+    /**
+     *
+     * @return {unknown[] | any[]}
+     */
+    get values() {
+
+        return Object.values( this._collection )
+
+    }
+    /**
+     *
+     * @param value
+     * @param validators
+     * @private
+     */
+    static _validate( value, validators ) {
+
+        for ( let validatorIndex = 0, numberOfValidators = validators.length ; validatorIndex < numberOfValidators ; validatorIndex++ ) {
+
+            let validator = validators[ validatorIndex ]
+
+            if ( !validator.validator( value ) ) {
+
+                const error = validator.error
+                if ( isString( error ) ) {
+                    throw new TypeError( error )
+                } else if ( isFunction( error ) ) {
+                    throw new TypeError( error( value ) )
+                } else {
+                    throw new TypeError( `${ value } is invalid.` )
+                }
+
+            }
+
+        }
+
+    }
+    /**
+     *
+     * @param value
+     * @return {TStore} The current instance (this)
+     */
+    setCollection( value ) {
+
+        this.collection = value
+        return this
+
+    }
+
+    /**
+     *
+     * @param value
+     * @return {TStore} The current instance (this)
+     */
+    setAllowOverride( value ) {
+
+        this.allowOverride = value
+        return this
+
+    }
+
+    /**
+     *
+     * @param value
+     * @return {TStore} The current instance (this)
+     */
+    setKeyValidators( value ) {
+
+        this.keyValidators( value )
+        return this
+
+    }
+
+    /**
+     *
+     * @param value
+     * @return {TStore} The current instance (this)
+     */
+    setValueValidators( value ) {
+
+        this.valueValidators( value )
+        return this
+
+    }
+
+    /**
+     * Allow to add new key value pair, the key cannot be null, undefined, or an empty string.
+     * In case the key already exist, the value will be overwritten if force params is true or this
+     * allow overriding else it throw an TypeError.
+     *
+     * @param {*} key
+     * @param {*} value
+     * @param {Boolean} force
+     * @return {TStore} The current instance (this)
+     */
+    add( key, value, force = false ) {
+
+        if ( this.contain( key ) && ( !this._allowOverride && !force ) ) {
+            throw new TypeError( `Item with key (${ key }) already exist in collection !` )
+        }
+
+        TStore._validate( key, this._keyValidators )
+        TStore._validate( value, this._valueValidators )
+
+        this._collection[ key ] = value
+
+        return this
+
+    }
+
+    /**
+     *
+     * @param key
+     * @return {boolean}
+     */
+    contain( key ) {
+
+        return isNotUndefined( this._collection[ key ] )
+
+    }
+
+    /**
+     * Return the value associated to the key.
+     *
+     * @param key
+     * @returns {*}
+     */
+    get( key ) {
+
+        return this._collection[ key ]
+
+    }
+
+    /**
+     * Remove to value from the cache. Does nothing if the key does not exist.
+     *
+     * @param key
+     * @return {TStore} The current instance (this)
+     */
+    remove( key ) {
+
+        delete this._collection[ key ]
+
+        return this
+
+    }
+
+    /**
+     * Clear the cache and reset collection to an empty object.
+     * @return {TStore} The current instance (this)
+     */
+    clear() {
+
+        this._collection = {}
+
+        return this
+
+    }
+
+}
+
+export { TStore }

package/sources/cores/_cores.js

@@ -0,0 +1,13 @@
+/**
+ * @module InputDevice
+ * @description Intermediary export file for cores. Export [Constants]{@link globals}, [TStore]{@link TStore}, [TAbstractFactory]{@link TAbstractFactory}, [TCloningFactory]{@link TCloningFactory}, and [TInstancingFactory]{@link TInstancingFactory}
+ *
+ * @author [Tristan Valcke]{@link https://github.com/Itee}
+ * @license [BSD-3-Clause]{@link https://opensource.org/licenses/BSD-3-Clause}
+ */
+
+export * from './TConstants.js'
+export { TStore } from './TStore.js'
+export { TAbstractFactory } from './TAbstractFactory.js'
+export { TCloningFactory } from './TCloningFactory.js'
+export { TInstancingFactory } from './TInstancingFactory.js'

package/sources/input_devices/TKeyboardController.js

@@ -0,0 +1,158 @@
+/* eslint-env browser */
+
+import { DefaultLogger as TLogger } from '@itee/core'
+import { Keys }                     from '../cores/TConstants.js'
+
+/**
+ * @class
+ * @classdesc TKeyboardController allow single source of thruth for keyboard state checking (based on Lee Stemkoski work).
+ * See TKeyboardController.k object data below for names of keys whose state can be polled
+ *
+ * @author [Tristan Valcke]{@link https://github.com/Itee}
+ * @license [BSD-3-Clause]{@link https://opensource.org/licenses/BSD-3-Clause}
+ * @example {@lang javascript}
+ * // (1) create a global variable:
+ * var keyboard = new TKeyboardController();
+ *
+ * // (2) during main loop:
+ * keyboard.update();
+ *
+ * // (3) check state of keys:
+ * keyboard.down("A")    -- true for one update cycle after key is pressed
+ * keyboard.pressed("A") -- true as long as key is being pressed
+ * keyboard.up("A")      -- true for one update cycle after key is released
+ */
+class TKeyboardController {
+
+    /**
+     *
+     * @param parameters
+     */
+    // eslint-disable-next-line no-unused-vars
+    constructor( parameters = {} ) {
+
+        //         const _parameters = {
+        //             ...{},
+        //             ...parameters
+        //         }
+
+        // bind keyEvents
+        document.addEventListener( 'keydown', TKeyboardController.onKeyDown, false )
+        document.addEventListener( 'keyup', TKeyboardController.onKeyUp, false )
+
+    }
+    /**
+     *
+     * @param keyCode
+     * @return {string}
+     */
+    static keyName( keyCode ) {
+        return ( TKeyboardController.k[ keyCode ] !== null ) ?
+               TKeyboardController.k[ keyCode ] :
+               String.fromCharCode( keyCode )
+    }
+    /**
+     *
+     * @param event
+     */
+    static onKeyUp( event ) {
+        var key = TKeyboardController.keyName( event.keyCode )
+        if ( TKeyboardController.status[ key ] ) {
+            TKeyboardController.status[ key ].pressed = false
+        }
+    }
+    /**
+     *
+     * @param event
+     */
+    static onKeyDown( event ) {
+        var key = TKeyboardController.keyName( event.keyCode )
+        if ( !TKeyboardController.status[ key ] ) {
+            TKeyboardController.status[ key ] = {
+                down:              false,
+                pressed:           false,
+                up:                false,
+                updatedPreviously: false
+            }
+        }
+    }
+    /**
+     *
+     */
+    update() {
+        for ( var key in TKeyboardController.status ) {
+            // insure that every keypress has "down" status exactly once
+            if ( !TKeyboardController.status[ key ].updatedPreviously ) {
+                TKeyboardController.status[ key ].down              = true
+                TKeyboardController.status[ key ].pressed           = true
+                TKeyboardController.status[ key ].updatedPreviously = true
+            } else { // updated previously
+                TKeyboardController.status[ key ].down = false
+            }
+
+            // key has been flagged as "up" since last update
+            if ( TKeyboardController.status[ key ].up ) {
+                delete TKeyboardController.status[ key ]
+                continue // move on to next key
+            }
+
+            if ( !TKeyboardController.status[ key ].pressed ) // key released
+            {
+                TKeyboardController.status[ key ].up = true
+            }
+        }
+    }
+
+    /**
+     *
+     * @param keyName
+     * @return {*}
+     */
+    down( keyName ) {
+        return ( TKeyboardController.status[ keyName ] && TKeyboardController.status[ keyName ].down )
+    }
+
+    /**
+     *
+     * @param keyName
+     * @return {*|pressed|boolean}
+     */
+    pressed( keyName ) {
+        return ( TKeyboardController.status[ keyName ] && TKeyboardController.status[ keyName ].pressed )
+    }
+
+    /**
+     *
+     * @param keyName
+     * @return {*}
+     */
+    up( keyName ) {
+        return ( TKeyboardController.status[ keyName ] && TKeyboardController.status[ keyName ].up )
+    }
+
+    /**
+     *
+     */
+    debug() {
+        var list = 'Keys active: '
+        for ( var arg in TKeyboardController.status ) {
+            list += ' ' + arg
+        }
+        TLogger.log( list )
+    }
+
+}
+
+/**
+ *
+ * @type {Keys}
+ */
+TKeyboardController.k = Keys
+
+/**
+ *
+ * @type {{}}
+ */
+TKeyboardController.status = {}
+
+export { TKeyboardController }

package/sources/input_devices/TMouseController.js

@@ -0,0 +1,31 @@
+/* eslint-env browser */
+
+/**
+ * @class
+ * @classdesc TMouseController allow single source of thruth for mouse state checking
+ * @author [Tristan Valcke]{@link https://github.com/Itee}
+ * @license [BSD-3-Clause]{@link https://opensource.org/licenses/BSD-3-Clause}
+ * @example
+ * (1) create a global variable:
+ *      var keyboard = new TKeyboardController();
+ * (2) during main loop:
+ *       keyboard.update();
+ * (3) check state of keys:
+ *       keyboard.down("A")    -- true for one update cycle after key is pressed
+ *       keyboard.pressed("A") -- true as long as key is being pressed
+ *       keyboard.up("A")      -- true for one update cycle after key is released
+ *
+ *  See TKeyboardController.k object data below for names of keys whose state can be polled
+ */
+class TMouseController {
+
+    /**
+     * @constructor
+     */
+    constructor( /*parameters = {}*/ ) {
+
+    }
+
+}
+
+export { TMouseController }

package/sources/input_devices/_inputDevices.js

@@ -0,0 +1,11 @@
+/**
+ * @module InputDevice
+ * @description Intermediary export file for input devices stuff. Export [TKeyboardController]{@link TKeyboardController} and [TMouseController]{@link TMouseController}
+ *
+ * @author [Tristan Valcke]{@link https://github.com/Itee}
+ * @license [BSD-3-Clause]{@link https://opensource.org/licenses/BSD-3-Clause}
+ */
+
+export { TKeyboardController } from './TKeyboardController.js'
+export { TMouseController } from './TMouseController.js'
+

package/sources/loaders/TBinaryConverter.js

@@ -0,0 +1,35 @@
+//import { DefaultBinarySerializer } from './TBinarySerializer'
+
+class TBinaryConverter {
+
+    constructor( targetType, serializer = null ) {
+//    constructor ( targetType, serializer = DefaultBinarySerializer ) {
+
+        this.targetCtor = targetType
+        this.serializer = serializer
+
+    }
+
+    /**
+     *
+     * @param {TBinaryWriter} writer
+     * @param instance
+     * @param options
+     */
+    to( writer, instance, options = {} ) { }
+
+    /**
+     *
+     * @param {TBinaryReader} reader
+     * @param options
+     * @returns {*}
+     */
+    from( reader, options = {} ) {
+
+        return new this.targetCtor()
+
+    }
+
+}
+
+export { TBinaryConverter }