@ondoher/enigma 1.0.2 → 1.0.5

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,112 @@ export default class Encoder {
 	}
 
 	/**
-	 * Call this method to set a function to be called when important events
-	 * happen to a component.
+	 *
+	 * @param {number | string} input
+	 * @param {Direction} direction
+	 */
+	fireInput(input, direction) {
+		if (typeof input === 'number') input = this.connectorToLetter(input)
+
+		/** @type {EventData} */
+		let eventData = {
+			name: this.name,
+			type: this.type,
+			direction,
+			description: `${this.type} "${this.name}" received signal on ${input}`,
+			event: 'input',
+			input: input
+		}
+
+		this.fire('input', this.name, eventData);
+	}
+
+	/**
+	 *
+	 * @param {number | string} output
+	 * @param {Direction} direction
+	 */
+	fireOutput(output, direction) {
+		if (typeof output === 'number') output = this.connectorToLetter(output)
+
+		/** @type {EventData} */
+		let eventData = {
+			name: this.name,
+			type: this.type,
+			direction,
+			description: `${this.type} "${this.name}" sent signal on ${output}`,
+			event: 'output',
+			output: output
+		}
+		this.fire('output', this.name, eventData);
+	}
+
+	/**
+	 *
+	 * @param {number | string} input
+	 * @param {number | string} output
+	 * @param {Direction} direction
+	 */
+	fireTranslate(input, output, direction) {
+		if (typeof input === 'number') input = this.connectorToLetter(input)
+		if (typeof output === 'number') output = this.connectorToLetter(output)
+
+		/** @type {EventData} */
+		let eventData = {
+			name: this.name,
+			type: this.type,
+			direction,
+			description: `${this.type} "${this.name}" translated ${input} to ${output}`,
+			event: 'translate',
+			input, output
+		}
+		this.fire('translate', this.name, eventData);
+	}
 
-	 * @param {Listener} cb the function to be called.
+	/**
+	 *
+	 * @param {number | string} input
+	 * @param {number | string} output
+	 * @param {Direction} direction
+	 */
+	fireEncodeSet(input, output, direction) {
+		this.fireInput(input, direction);
+		this.fireOutput(output, direction);
+		this.fireTranslate(input, output, direction);
+	}
+
+	/**
+	 * 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,47 +11,33 @@ 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;
+		this._configuration = {reflector, ringSettings: [], rotors: [], plugs: ''};
 	}
 
 	/**
@@ -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,36 +100,46 @@ 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];
 
 		this._configuration = {...this._configuration,
 			rotors,
-			ringOffsets,
+			ringSettings: ringOffsets,
 			plugs: this.plugboard.plugs
 		}
 	}
 
 	/**
-	 * Call this method to step the rotors one time. This method will manage the
+	 * Call this method to "step" the rotors one time. This method will manage the
 	 * 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,
+					description: `rotor ${rotor.name} double stepping from ${rotor.offset}`,
+					type: this.type,
+					event: "double-step",
+					offset: 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;
@@ -171,8 +167,7 @@ export default class Enigma {
 			start = setup;
 		}
 
-		start = [...start].reverse();
-
+		start = [...start].reverse().join('');
 		// reset the rotation pending state
 		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.fireInput(letter, "right");
 		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,11 @@ 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.fireOutput(outputLetter, "left");
+		this.fireTranslate(letter, outputLetter, "end-to-end");
+		return outputLetter;
 	}
 
 	/**
@@ -227,7 +223,7 @@ export default class Enigma {
 	 *
 	 * @returns {String} the encoded string.
 	 */
-	encode(start, text) {
+	translate(start, text) {
 		this.setStart(start)
 		let letters = [...text];
 		let output = letters.map(function(letter) {
@@ -238,27 +234,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 */
@@ -35,7 +20,7 @@ interface EncoderSetup {
  * Defines how the enigma hardware is constructed. These are the settings that
  * cannot be changed
  */
-interface EnigmaSetup extends EncoderConfiguration {
+interface EnigmaSetup extends EncoderSetup {
 	/** which entry disc is part of the machine, defaults to "default" */
 	entryDisc?: string;
 	/** which reflector is part of the machine */
@@ -98,4 +83,116 @@ 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: "translate";
+
+	/** the direction the signal was sent */
+	direction: Direction;
+
+	/** the starting value */
+	input: number | string;
+
+	/** the translated value */
+	output: number | string;
+}
+
+/**
+ * defines the data sent for a rotor step
+ */
+type StepData = {
+	/** the event name */
+	event: "step";
+
+	/** the starting rotor position */
+	start: number;
+
+	/** the ending rotor position */
+	stop: number;
+
+	/** the locations of the turnover points for this rotor */
+	turnover: boolean;
+}
+
+type DoubleStepData = {
+	event: "double-step",
+	offset: number;
+}
+
+/**
+ * Defines the data sent with an input event
+ */
+type InputData = {
+	/** the event name */
+	event: "input";
+
+	/** the input connection */
+	input: number | string;
+
+	/** the direction the signal was sent */
+	direction: Direction;
+}
+
+/**
+ * Defines the data sent with an output event
+ */
+type OutputData = {
+	/** the event name */
+	event: "output";
+
+	/** the output connection */
+	output: number | string;
+
+	/** the direction the signal was sent */
+	direction: Direction;
+}
+
+/** Defines the discriminated union for all the event data */
+type EventData = EventBase & (TranslateData | StepData | InputData | OutputData | DoubleStepData);
+
+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;
@@ -57,20 +57,15 @@ export default class PlugBoard extends Encoder {
 	 * Call this method to convert the input connector number to the output in
 	 * the given direction.
 	 *
-	 * @param {String} direction either right for moving towards the reflector or
+	 * @param {Direction} direction either right for moving towards the reflector or
 	 * 	left if moving back
 	 * @param {Number} input the input connector
 	 * @returns {Number} the output connector
 	 */
 	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);
@@ -24,20 +24,16 @@ export default class Reflector extends Encoder {
 	 * the point where direction changes this does not have a distinction
 	 * between a left and right signal path.
 	 *
-	 * @param {Direction} _direction since this is the point where signal direction
+	 * @param {Direction} direction since this is the point where signal direction
 	 * changes from right to left this parameter is not used.
 	 * @param {Number} input this is the input connector
 	 *
 	 * @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;
 	}