Luhn Algo , JavaScript Component

inputLuhn.js

import React, { Component } from 'react'

import Luhn from './luhn.js'

class  Input extends Component {  

	 constructor(props, context) {
      super(props, context);

      this.state = {
        value : '',
        validSiren : false,
      }

    	this.valid = this.valid.bind(this)
    	this.error = this.error.bind(this)
    }

	handleChange(e) {
		this.setState({value : e.target.value })
	}

	valid() {
		(!this.state.validSiren)
			? this.setState({ validSiren : true })
			: true
	}
  
	error() {
		(this.state.validSiren)
     			? this.setState({ validSiren : false })
     			: true
	}
  
	render() {
		return (
			<div>
      
			    <input 	type="number"
			           	id='inputID'
    			     		onChange={this.handleChange.bind(this)}/>
				
          {(this.state.value.length === 9) 
            ? <Luhn siren={this.state.value} 
                valid={this.valid}
                error={this.error} /> 
            : true }
			
			</div>
		)
	}
}

export default Input

luhn.js

import React from 'react'

const Luhn = ({siren,valid,error}) => {

      if ((!(siren)) || (siren.toString().length != 9) || (!Number(siren.toString())) ){
			error()
                  return('')}
      else {
            const splited = siren.toString().split('')
                  //transform to array and sperate number   
            const reversed = splited.reverse()
                  //reverse array's elements
            const mapped = reversed.map((element,index) => {
                  //double paire number , make sum for keep uniq number.
                                          if (index % 2) { 
                                                return ((element * 2 ) > 9 ) 
                                                            ? (element * 2 - 9) 
                                                            : ( element * 2 )}
                                                /*return(((element * 2) - 1) % 9 + 1)*/
                                          else return Number(element) })
            const reduced = mapped.reduce((elt1, elt2) => { return (elt1 + elt2) })
                  //make sum of array's elements

            !(reduced % 10) ? valid() : error()
                  //then check if sum is 10 multiple
            return ('')
      }
}

export default  Luhn

LuhnSpec.js

/*
 * Function return true or false
 *	check if siren is valid, or not
 *	NOT accept space from siren syntax
 *	https://fr.wikipedia.org/wiki/Formule_de_Luhn
 *	run test with npm mocha
 * @siren Luhn formule 
 */

//* Begin of tests
describe('Valid SIREN Luhn Formule', () => {
	it('should do siren are valid', () => {

// Code :
	const Luhn = (siren) => {

		if ((!(siren)) || (siren.toString().length != 9) || (!Number(siren.toString())) ){
			return false
			}
		else {

			const splited = siren.toString().split('')
			const reversed = splited.reverse()
			const mapped = reversed.map((element,index) => {
							if (index % 2) {
								return ((element * 2 ) > 9 ) 
										? (element * 2 - 9) 
										: ( element * 2 )}
								/*return(((element * 2) - 1) % 9 + 1)*/
							else return Number(element) })
			const reduced = mapped.reduce((elt1, elt2) => { return (elt1 + elt2) })

			return (!(reduced % 10)) ? true : false
	}}

// Tests */
		const assert = require('assert')

		assert.strictEqual(typeof Luhn, "function")
		assert.equal(Luhn('111111111'), false, 'algo de base')
		assert.equal(Luhn('111111118'), true, 'algo de base')
		assert.equal(Luhn('422618728'), true, 'siren numbers string verif')
		assert.equal(Luhn(422618728), true, 'siren numbers valid verif')
		assert.equal(Luhn('494967938'), true, 'siren numbers string verif')
		assert.equal(Luhn(494967938), true, 'siren numbers string verif')
		assert.equal(Luhn('198442666'), false, 'siren numbers string invalide verif')
		assert.equal(Luhn(198442666), false, 'siren numbers string invalide verif')
		assert.equal(Luhn('198442666198442666'), false, 'string siren numbers too big')
		assert.equal(Luhn(198442666198442666), false, 'siren numbers too big')
		assert.equal(Luhn('1984'), false, 'string siren numbers too small')
		assert.equal(Luhn(42), false, 'siren numbers  too small')
		assert.equal(Luhn(0), false, 'uniq number')
		assert.equal(Luhn(), false, 'null')
		assert.equal(Luhn(''), false, 'string empty')
		assert.equal(Luhn('c0deKo242'), false, 'siren letters string')

	})
})
// End of tests */