@ondoher/enigma 1.0.1 → 1.0.3

package/README.md

@@ -4,6 +4,7 @@
 
 # Table of Contents
 [Getting Started](#getting-started)
+
 [Simulation](#simulation)
 - [Events](#events)
 - [Plugboard](#plugboard)
@@ -37,7 +38,7 @@ You can then import this into your code like this:
 ```JavaScript
 import {Enigma} from '@ondoher/enigma';
 
-var enigma = new Enigma({reflector: 'B'});
+var enigma = new Enigma("I", {reflector: 'B'});
 ```
 
 In addition to this api, there is also [documentation](https://github.com/Ondoher/enigma/blob/main/docs/enigma.md)
@@ -419,7 +420,7 @@ An array of the installed rotors
 ```javascript
 import {Enigma} from '@ondoher/enigma';
 
-var enigma = new Enigma({reflector: 'B'});
+var enigma = new Enigma("I", {reflector: 'B'});
 
 enigma.configure({
     rotors: ['III', 'VI', 'VIII'],

package/jsconfig.json

@@ -1,3 +1,9 @@
 {
-
+  "compilerOptions": {
+    "target": "es2020", // Or a newer version like "es2020"
+    "module": "commonjs"
+  },
+  "exclude": [
+    "node_modules"
+  ]
 }

package/lib/enigma/Encoder.js

@@ -10,14 +10,21 @@ export default class Encoder {
 	 * Constructor for the base encoder
 	 *
 	 * @param {string} name
+	 * @param {ComponentType} type
 	 * @param {EncoderSetup} settings
 	 */
-	constructor(name, settings) {
+	constructor(name, type, settings) {
 		let {cb, alphabet = STANDARD_ALPHABET} = settings;
 		this.name = name;
+		this.type = type;
 		this.alphabet = alphabet;
 		this.contactCount = alphabet.length;
-		this.cb = cb;
+		/** @type {{[name: string]: Listener}} */
+		this.listeners = {}
+
+		if (cb) {
+			this.listeners["constructor"] = cb;
+		}
 	}
 
 	/**
@@ -31,6 +38,52 @@ export default class Encoder {
 		return (connector + this.contactCount * 2) % this.contactCount;
 	}
 
+	/**
+	 *
+	 * @param {string} letter
+	 *
+	 * @returns {boolean}
+	 */
+	verifyLetter(letter) {
+		if (letter.length !== 1 || this.alphabet.indexOf(letter) === -1) {
+			if (letter !== ' ') {
+				console.warn(`Unexpected character ${letter}`);
+			}
+			return false;
+		}
+
+		return true;
+	}
+
+	/**
+	 * Call this method to convert a letter to a connector value
+	 *
+	 * @param {string} letter
+	 * @returns {number | undefined}
+	 */
+	letterToConnector(letter) {
+		if (!this.verifyLetter(letter)) {
+			return;
+		}
+
+		return this.alphabet.indexOf(letter);
+	}
+
+	/**
+	 * Call this method to turn a connector to a letter value
+	 *
+	 * @param {number} connector
+	 * @returns {string | undefined}
+	 */
+	connectorToLetter(connector) {
+		if (connector >= this.alphabet.length) {
+			console.warn(`Unexpected connector ${connector}`);
+
+		}
+
+		return this.alphabet[connector];
+	}
+
 	/**
 	 * Given an alphabetic connection map, convert that into an array of
 	 * numbers. The index into the array or string is the input connector, and
@@ -79,23 +132,78 @@ export default class Encoder {
 	}
 
 	/**
-	 * Call this method to set a function to be called when important events
-	 * happen to a component.
+	 *
+	 * @param {number | string} start
+	 * @param {number | string} stop
+	 * @param {Direction} direction
+	 */
+	fireEncodeSet(start, stop, direction) {
+		/** @type {EventData} */
+		let eventData = {
+			name: this.name,
+			type: this.type,
+			description: `input: ${start}`,
+			event: 'input',
+			input: start
+		}
+
+		this.fire('input', this.name, eventData);
 
-	 * @param {Listener} cb the function to be called.
+		if (typeof start === 'number') start = this.connectorToLetter(start)
+		if (typeof stop === 'number') stop = this.connectorToLetter(stop)
+		eventData = {
+			name: this.name,
+			type: this.type,
+			description: `${this.type}: ${this.name} translate ${start} to ${stop}`,
+			event: 'translate',
+			direction,
+			start,
+			stop
+		}
+		this.fire('translate', this.name, eventData);
+
+		eventData = {
+			name: this.name,
+			type: this.type,
+			description: `output: ${stop}`,
+			event: 'output',
+			output: stop
+		}
+		this.fire('output', this.name, eventData);
+	}
+
+	/**
+	 * Call this method to add a function to be called when important events
+	 * happen to a component. The name can be used to later remove the listener
+	 *
+	 * @param {string} name - the name of the listener
+	 * @param {Listener} cb - the function to be called.
+	 */
+	listen(name, cb) {
+		this.listeners[name] = cb;
+	}
+
+	/**
+	 * Call this method to remove a listener
+	 *
+	 * @param {string} name - the name of the listener
 	 */
-	listen(cb) {
-		this.cb = cb;
+	unlisten(name) {
+		delete this.listeners[name];
 	}
 
 	/**
-	 * Call this method to call the event listener
+	 * Call this method to call any event listeners
 	 *
-	 * @param {String} name the name of the event
-	 * @param  {unknown[]} rest the parameters to pass to the callback
+	 * @param {EventName} event - the event being fired
+	 * @param {String} name - the name of the component firing the event
+	 * @param {EventData} data - the event data
 	 */
-	fire(name, ...rest) {
-		if (this.cb) this.cb(name, ...rest);
+	fire(event, name, data) {
+		let listeners = Object.values(this.listeners);
+		for (let cb of listeners) {
+			cb(event, name, data)
+		}
 	}
 
 }

package/lib/enigma/Enigma.js

@@ -11,49 +11,35 @@ import Encoder from "./Encoder.js";
  * parameters to the constructor and the config method reference the names of
  * standard Enigma parts. These are retrieved from the Inventory instance
  */
-export default class Enigma {
+export default class Enigma extends Encoder {
 	/**
 	 * The constructor for the Enigma. This represents the unconfigurable
 	 * settings of the device.
 	 *
+	 * @param {string} name
 	 * @param {EnigmaSetup} settings
 	 */
-	constructor(settings) {
-		let {entryDisc = 'default', reflector, alphabet = STANDARD_ALPHABET, model = "Enigma"} = settings;
+	constructor(name,  settings) {
+		super(name, "Enigma", settings)
+		let {entryDisc = 'default', reflector, alphabet = STANDARD_ALPHABET} = settings;
 		let entryDiscSettings = inventory.getEntryDisc(entryDisc)
 
 		let reflectorSettings = inventory.getReflector(reflector)
 		this.alphabet = alphabet;
-		this.plugboard = new PlugBoard('plugboard', {});
-		this.entryDisc = new EntryDisc('entry-disc', entryDiscSettings);
-		this.reflector = new Reflector('reflector', reflectorSettings)
+		this.plugboard = new PlugBoard('default', {});
+		this.entryDisc = new EntryDisc('default', entryDiscSettings);
+		this.reflector = new Reflector(reflector, reflectorSettings)
 		this.length = alphabet.length;
 		/** @type {Rotor[]} */
 		this._rotors = [];
 		/** @type {{[rotor: number]: boolean}} */
 		this.pending = [];
-		this.name = model;
 		/** @type {Encoder[]} */
 		this.encoders = [];
 		/**@type {SimplifiedConfiguration & {reflector: string}} */
 		this._configuration = {reflector}
 	}
 
-	/**
-	 * Call this method to normalize a connector number to be within the
-	 * the length of the current alphabet
-	 *
-	 * @param {Number} connector the number to be normalized
-	 *
-	 * @returns {Number} the normalized connector number
-	 */
-	normalize(connector) {
-		connector += this.length;
-		connector = connector % this.length
-
-		return connector;
-	}
-
 	/**
 	 * the configured rotors
 	 *
@@ -94,7 +80,7 @@ export default class Enigma {
 		/** @type {number[]} */
 		let ringOffsets = []
 
-		// because the rotors are specified in the reverse other they are used,
+		// because the rotors are specified in the reverse order they are used,
 		// we have to do the same for the ringSettings.
 		if (Array.isArray(ringSettings)) {
 			ringSettings = ringSettings.reverse();
@@ -114,7 +100,7 @@ export default class Enigma {
 		}
 
 		this._rotors = useRotors.map(function(name, idx) {
-			return new Rotor(`rotor-${name}`, {...inventory.getRotor(name), alphabet: this.alphabet, ringSetting: ringOffsets[idx], cb: this.cb});
+			return new Rotor(`${name}`, {...inventory.getRotor(name), alphabet: this.alphabet, ringSetting: ringOffsets[idx], cb: this.cb});
 		}, this);
 
 		this.encoders = [this.plugboard, this.entryDisc, ...this.rotors];
@@ -131,19 +117,28 @@ export default class Enigma {
 	 * stepping between all rotors
 	 */
 	step() {
-		this._rotors.forEach(function(rotor, idx) {
+		this._rotors.forEach((rotor, idx) => {
 			if (rotor.isFixed()) return;
 
 			// This is the double stepping. Only do this for the middle rotor
 			if (rotor.willTurnover() && idx === 1) {
 				this.pending[idx] = true
+				/** @type {EventData} */
+				let eventData = {
+					name: rotor.name,
+					event: "double-step",
+					offset: rotor.offset,
+					description: `rotor ${rotor.name} double stepping from ${rotor.offset}`
+				}
+
+				this.fire('double-step', rotor.name, eventData);
 			};
 
 			if (this.pending[idx]) {
 				this.pending[idx] = false;
 				if (rotor.step()) this.pending[idx + 1] = true;
 			}
-		}, this);
+		});
 
 		// The first rotor is always stepping
 		this.pending[0] = true;
@@ -190,23 +185,22 @@ export default class Enigma {
 	 */
 	keyPress(letter) {
 		letter = letter.toUpperCase();
-		if (letter.length !== 1 || this.alphabet.indexOf(letter) === -1) {
-			if (letter !== ' ')
-				console.warn(`Unexpected character ${letter}`);
+		if (!this.verifyLetter(letter)) {
 			return;
 		}
 
-		this.fire('input', this.name, `input ${letter}`, {letter})
+		let connector = this.letterToConnector(letter);
+
 		this.step();
 
 		// encode to the right
-		let connector =  this.encoders.reduce(function(connector, encoder, idx) {
+		connector =  this.encoders.reduce(function(connector, encoder, idx) {
 			connector = encoder.encode('right', connector);
 			return connector;
 		}.bind(this), this.alphabet.indexOf(letter));
 
 		// reflector
-		connector = this.reflector.encode('right', connector);
+		connector = this.reflector.encode('turn-around', connector);
 
 		// encode to the left
 		connector = this.encoders.reduceRight(function(connector, encoder) {
@@ -214,9 +208,10 @@ export default class Enigma {
 			return connector;
 		}.bind(this), connector)
 
-		letter = this.alphabet[connector];
-		this.fire('output', this.name, `output ${letter}`, {letter})
-		return letter;
+		const outputLetter = this.connectorToLetter(connector);
+
+		this.fireEncodeSet(letter, outputLetter, "end-to-end")
+		return outputLetter;
 	}
 
 	/**
@@ -238,27 +233,17 @@ export default class Enigma {
 	}
 
 	/**
-	 * Call this method to call the event listener
 	 *
-	 * @param {String} type the name of the event
-	 * @param  {...any} rest the parameters to pass to the callback
+	 * @param {string} name
+	 * @param {Listener} cb
 	 */
-	fire(type, ...rest) {
-		if (this.cb) this.cb(type, ...rest);
-	}
-
-	/**
-	 * Call this method to set a function to be called when important events
-	 * happen to a component.
+	listen(name, cb) {
+		super.listen(name, cb);
 
-	 * @param {Listener} cb the function to be called.
-	 */
-	listen(cb) {
-		this.cb = cb;
-		this.encoders.forEach(function(encoder) {
-			encoder.listen(cb);
-		});
+		for (let encoder of this.encoders) {
+			encoder.listen(name, cb)
+		}
 
-		this.reflector.listen(cb);
+		this.reflector.listen(name, cb);
 	}
 }

package/lib/enigma/EnigmaTypes.d.ts

@@ -1,21 +1,6 @@
-// type Listener = (
-// 	/** name of the event being fired*/
-// 	event: string,
 
-// 	/** the name of th component firing the event */
-// 	name: string,
 
-// 	/** a human readable description of the event */
-// 	message: string,
-
-// 	/** event specific data */
-// 	info: object
-
-// ) => void;
-
-
-
-type Listener = (...params: unknown[]) => void;
+type ComponentType = ("Entry Wheel" | "Plugboard" | "Reflector" | "Rotor" | "Enigma")
 
 interface EncoderSetup {
 	/** if specified defines an alternate alphabet for the enigma */
@@ -98,4 +83,111 @@ interface RotorSetup extends EncoderSetup {
 	turnovers?: string;
 }
 
-type Direction = ("right"|"left")
+/**
+ * Defines the possible directions for a translation.
+ *
+ * - **right** - the signal is moving from the right to the left
+ * - **left** - the signal is moving from left to right
+ * - **turn-around** - the signal is transitioning between directions, this is
+ * sent from the reflector
+ */
+type Direction = ("right" | "left" | "turn-around" | "end-to-end");
+
+/**
+ * Defines the possible events sent from the enigma components.
+ *
+ * **translate** - fired when the input signal is changed from one value to another
+ * **input** - fired when a signal first enters the component
+ * **output** - fired when the signal exits the component
+ *
+ */
+type EventName = ("translate" | "input" | "output" | "step" | "double-step");
+
+/**
+ * Defines the common data for an event
+ */
+type EventBase = {
+	/** the name of the component sending the event */
+	name: string;
+
+	type: ComponentType;
+
+	/** a human readable description of the event */
+	description: string;
+}
+
+/**
+ * Defines the data sent for a translate event
+ */
+type TranslateData = {
+	/** the event name */
+	event: EventName = "translate";
+
+	/** the direction the signal was sent */
+	direction: Direction;
+
+	/** the starting value */
+	start: number | string;
+
+	/** the translated value */
+	stop: number | string;
+}
+
+/**
+ * defines the data sent for a rotor step
+ */
+type StepData = {
+	/** the event name */
+	event: EventName = "step";
+
+	/** the starting rotor position */
+	start: number | string;
+
+	/** the ending rotor position */
+	stop: number | string
+
+	/** the locations of the turnover points for this rotor */
+	turnover: boolean;
+}
+
+type DoubleStepData = {
+	eventName: EventName = "double-step",
+	rotor: string;
+	offset: number;
+}
+
+/**
+ * Defines the data sent with an input event
+ */
+type InputData = {
+	/** the event name */
+	event: EventName = "input";
+
+	/** the input connection */
+	input: number | string;
+}
+
+/**
+ * Defines the data sent with an output event
+ */
+type OutputData = {
+	/** the event name */
+	event: EventName = "output";
+
+	/** the output connection */
+	output: number | string;
+}
+
+/** Defines the discriminated union for all the event data */
+type EventData = EventBase & (TranslateData | StepData | InputData | OutputData);
+
+type Listener = (
+	/** name of the event being fired*/
+	event: string,
+
+	/** the name of th component firing the event */
+	name: string,
+
+	/** event specific data */
+	data:  EventData
+) => void;

package/lib/enigma/EntryDisc.js

@@ -15,7 +15,7 @@ export default class EntryDisc extends Encoder {
 	 * 	between input and output contacts
 	 */
 	constructor(name, settings) {
-		super(name, settings);
+		super(name, "Entry Wheel", settings);
 		var {map = STANDARD_ALPHABET} = settings;
 		this.rightMap = this.makeMap(map);
 		this.leftMap = this.makeReverseMap(this.rightMap);
@@ -31,14 +31,8 @@ export default class EntryDisc extends Encoder {
 	 */
 	encode(direction, input) {
 		var result = direction === 'right' ? this.rightMap[input]: this.leftMap[input];
-		var evName = direction === 'right' ? 'encode-right' : 'encode-left';
 
-		this.fire(evName, this.name,
-			`${evName} ${this.name}, input: ${input}, output: ${result}`, {
-				input: input,
-				output: result,
-			}
-		);
+		this.fireEncodeSet(input, result, direction);
 		return result;
 	}
 }

package/lib/enigma/PlugBoard.js

@@ -14,7 +14,7 @@ export default class PlugBoard extends Encoder {
 	 * 	using an alternate alphabet
 	 */
 	constructor(name = 'plugboard', settings = {}) {
-		super(name, settings);
+		super(name, "Plugboard", settings);
 
 		var {alphabet = STANDARD_ALPHABET, map} = settings;
 		this.alphabet = alphabet;
@@ -64,13 +64,8 @@ export default class PlugBoard extends Encoder {
 	 */
 	encode(direction, input) {
 		var result = direction === 'right' ? this.rightMap[input]: this.leftMap[input];
-		var evName = direction === 'right' ? 'encode-right' : 'encode-left';
-		this.fire(evName, this.name,
-			`${evName} ${this.name}, input: ${input}, output: ${result}`, {
-				input: input,
-				output: result,
-			}
-		);
+
+		this.fireEncodeSet(input, result, direction);
 
 		return result;
 	}

package/lib/enigma/Reflector.js

@@ -13,7 +13,7 @@ export default class Reflector extends Encoder {
 	 * @param {EncoderSetup} settings The definition of the reflector
 	 */
 	constructor(name, settings) {
-		super(name, settings);
+		super(name, "Reflector", settings);
 		var {map = STANDARD_ALPHABET} = settings;
 
  		this.map = this.makeMap(map);
@@ -30,14 +30,10 @@ export default class Reflector extends Encoder {
 	 *
 	 * @returns {Number} the mapped output connector
 	 */
-	encode(_direction, input) {
+	encode(direction, input) {
 		var result = this.map[input];
-		this.fire('encode', this.name,
-			`encode ${this.name} ${input} ${result}`,
-			{
-				input: input,
-				output: result,
-			});
+
+		this.fireEncodeSet(input, result, direction)
 
 		return result;
 	}

package/lib/enigma/Rotor.js

@@ -17,8 +17,8 @@ export default class Rotor extends Encoder {
 	 * define the the rotor and how it is configured.
 	 */
 	constructor(name, settings) {
-		super(name, settings);
-		var { map = STANDARD_ALPHABET, turnovers = '', ringSetting = 0} = settings
+		super(name, "Rotor", settings);
+		let { map = STANDARD_ALPHABET, turnovers = '', ringSetting = 0} = settings
 
 		this.map = [...map];
 		this.rightMap = this.makeMap(map);
@@ -29,10 +29,13 @@ export default class Rotor extends Encoder {
 		this.turnoverLookup = this.makeMap(turnovers);
 		this.offset = 0;
 		if (turnovers === '') this.fixed = true;
-		this.turnovers = this.turnoverLookup.reduce(function(turnovers, turnover) {
-			turnovers[turnover] = true;
+		this.turnovers = turnovers;
+		/** @type {Set<number>} */
+		let turnoverSet = new Set();
+		this._turnovers = this.turnoverLookup.reduce((turnovers, turnover) => {
+			turnovers.add(turnover)
 			return turnovers;
-		}.bind(this), {});
+		}, turnoverSet);
 	}
 
 	/**
@@ -45,7 +48,7 @@ export default class Rotor extends Encoder {
 	 * ring setting.
 	 */
 	setStartPosition(connector) {
-		var pos = this.alphabet.indexOf(connector);
+		let pos = this.alphabet.indexOf(connector);
 		this.offset = this.normalize(pos - this.ringOffset);
 	}
 
@@ -63,54 +66,49 @@ export default class Rotor extends Encoder {
 	 * @returns {Number} the output connector in physical space.
 	 */
 	encode(direction, input) {
-		var map = direction === 'right' ? this.rightMap : this.leftMap;
-		var evName = direction === 'right' ? 'encode-right' : 'encode-left';
+		let map = direction === 'right' ? this.rightMap : this.leftMap;
 
 		//find the logical position of the input connector in the wiring map
-		var index = this.normalize(input + this.offset);
+		let index = this.normalize(input + this.offset);
 
 		// get the logical output connector and convert that to the physical
 		// output connector
-		var output = map[index];
-		var result = this.normalize(output - this.offset);
-
-		this.fire(evName, this.name,
-			`${evName} ${this.name}, input: ${input} output: ${result} relative input: ${index}, relative output: ${output} rotation: ${this.offset}`,
-			{
-				input : input,
-				output: result,
-				logicalInput: index,
-				logicalOutput: output,
-				rotation: this.offset,
-			}
-		);
+		let output = map[index];
+		let result = this.normalize(output - this.offset);
 
+		this.fireEncodeSet(input, result, direction);
 		return result;
 	}
 
 	/**
 	 * Call this method to step the rotor
 	 *
-	 * @returns {Boolean} true true if the next rotor should be stepped
+	 * @returns {Boolean} true if the next rotor should be stepped
 	 */
 	step() {
 		// Because the turnover notch is attached to the outer ring, and the
 		// logical coordinates are based on the wiring, the logical position of
 		// the notch for turnover needs to be adjusted to remove the ring offset.
+		let start = this.offset;
 		this.offset = this.normalize(this.offset + 1);
-		var turnoverOffset = this.normalize(this.offset + this.ringOffset);
+		let stop = this.offset;
+		let turnoverOffset = this.normalize(this.offset + this.ringOffset);
+
 
 		// turnover happens when we step past the turnover point
-		var turnover = this.turnovers[this.normalize(turnoverOffset - 1)];
+		let turnover = this._turnovers.has(this.normalize(turnoverOffset - 1));
+
+		/** @type {EventData} */
+		let eventData = {
+			name: this.name,
+			type: this.type,
+			description: `step ${this.name}, ${this.offset} ${this.normalize(this.offset + this.ringOffset)} ${turnoverOffset} ${Boolean(turnover)}`,
+			event: 'step',
+			turnover, start, stop
+		}
 
-		this.fire('step', this.name,
-			`step ${this.name}, ${this.offset} ${this.normalize(this.offset + this.ringOffset)} ${turnoverOffset} ${Boolean(turnover)}`,
-			{
-				rotation: this.offset,
-				ringSetting: this.ringOffset,
-				turnover: Boolean(turnover),
-			}
-		);
+		// console.log("firing", eventData);
+		this.fire('step', this.name, eventData);
 
 		return turnover;
 	}
@@ -123,10 +121,18 @@ export default class Rotor extends Encoder {
 	 * @returns true if this rotor will turnover on the next step
 	 */
 	willTurnover() {
-		var turnoverOffset = this.normalize(this.offset + this.ringOffset);
+		let turnoverOffset = this.normalize(this.offset + this.ringOffset);
 
 		// double stepping happens when we step to the turnover point
-		return this.turnovers[turnoverOffset];
+		return this._turnovers.has(turnoverOffset);
+	}
+
+	shouldTurnover() {
+		let turnoverOffset = this.normalize(this.offset + 1 + this.ringOffset);
+
+		// double stepping happens when we step to the turnover point
+		return this._turnovers.has(turnoverOffset);
+
 	}
 
 	/**

package/lib/enigma/tests/EnigmaSpec.js

@@ -5,11 +5,12 @@ import Enigma from "../Enigma.js";
 import { enigmaData } from './EnigmaData.js';
 
 describe('Enigma Test Cases', function() {
+	/** @type {Enigma} */
 	var enigma;
 
 	function messageLoop(messages, which, cb) {
 		return messages.find(function(message) {
-			var enigma = new Enigma({
+			var enigma = new Enigma("Test", {
 				reflector: message.setup.reflector
 			});
 
@@ -29,39 +30,42 @@ describe('Enigma Test Cases', function() {
 	describe('Stepping', function() {
 		var steps = {}
 		beforeEach(function() {
-			enigma = new Enigma({
+			enigma = new Enigma("I", {
 				reflector: 'B',
 			});
 
 			enigma.configure({rotors: ['I', 'II', 'III']});
 
-			enigma.listen(function(event, name, message, info) {
+			listen()
+		});
+
+		function listen() {
+			enigma.listen('test', (event, name, data) => {
 				if (event === 'step') {
 					steps[name] = steps[name] || [];
-					steps[name].push(info);
+					steps[name].push(data);
 				}
 			})
-
-		});
+		}
 
 		it ('should step only the right-most rotor when not at turnover', function() {
 			steps = {};
 			enigma.encode('AAA', 'A');
 			var stepped = Object.keys(steps);
 			expect(stepped.length).toBe(1);
-			expect(stepped[0]).toBe('rotor-III');
+			expect(stepped[0]).toBe('III');
 		});
 
 		it ('should step the next rotor when the previous turns over', function() {
 			steps = {};
 			enigma.encode('AAV', 'A');
-			expect(steps['rotor-II'].length).toBe(1);
+			expect(steps['II'].length).toBe(1);
 		});
 
 		it ('should double step when reaching the turn over', function() {
 			steps = {};
 			enigma.encode('ADV', 'AA');
-			expect(steps['rotor-II'].length).toBe(2);
+			expect(steps['II'].length).toBe(2);
 		});
 
 		it ('should double step on first step', function() {
@@ -69,8 +73,10 @@ describe('Enigma Test Cases', function() {
 
 			enigma.configure({rotors: ['III', 'VI', 'VIII'], ringSettings: [1, 8, 13]});
 
+			listen();
+
 			enigma.encode('UZV', 'AA');
-			expect(steps['rotor-VI'].length).toBe(1);
+			expect(steps['VI'].length).toBe(1);
 		});
 	})
 

package/lib/enigma/tests/RotorData.js

@@ -4,7 +4,7 @@ export const rotorData = {
 		map: 'BCDA',
 		reverseMap: [3, 0, 1, 2],
 		turnovers: 'AM',
-		turnoversMap: {0: true, 12: true}
+		turnoversMap: [0, 12]
 	},
 	I: {
 		map: 'EKMFLGDQVZNTOWYHXUSPAIBRCJ',

package/lib/enigma/tests/RotorSpec.js

@@ -29,7 +29,9 @@ describe('Rotor Test Cases', function() {
 				turnovers: rotorData.createData.turnovers,
 			});
 
-			expect(rotor.turnovers).toEqual(rotorData.createData.turnoversMap);
+			let turnovers = [...rotor._turnovers];
+
+			expect(turnovers).toEqual(rotorData.createData.turnoversMap);
 		})
 	})
 

package/lib/generator/Generator.js

@@ -136,7 +136,7 @@ export default class Generator {
 	 */
 	createRandomEnigma(model = "Enigma", reflectors = ['A', 'B', 'C']) {
 		let reflector = Random.pickOne(reflectors);
-		return new Enigma({model, reflector});
+		return new Enigma(model, {model, reflector});
 	}
 
 	/**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ondoher/enigma",
-  "version": "1.0.1",
-  "description": "Enigma machine simulator reference with tools and documentation to help you build your own.",
+  "version": "1.0.3",
+  "description": "Enigma machine simulator implementation with tools and documentation to help you build your own.",
   "main": "./lib/index.js",
   "scripts": {
     "test": "jasmine"