@ondoher/enigma 1.0.3 → 1.0.6

package/jsconfig.json

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

package/lib/enigma/Encoder.js

@@ -133,43 +133,77 @@ export default class Encoder {
 
 	/**
 	 *
-	 * @param {number | string} start
-	 * @param {number | string} stop
+	 * @param {number | string} input
 	 * @param {Direction} direction
 	 */
-	fireEncodeSet(start, stop, direction) {
+	fireInput(input, direction) {
+		if (typeof input === 'number') input = this.connectorToLetter(input)
+
 		/** @type {EventData} */
 		let eventData = {
 			name: this.name,
 			type: this.type,
-			description: `input: ${start}`,
+			direction,
+			description: `${this.type} "${this.name}" received signal on ${input}`,
 			event: 'input',
-			input: start
+			input: input
 		}
 
 		this.fire('input', this.name, eventData);
+	}
 
-		if (typeof start === 'number') start = this.connectorToLetter(start)
-		if (typeof stop === 'number') stop = this.connectorToLetter(stop)
-		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,
-			description: `${this.type}: ${this.name} translate ${start} to ${stop}`,
-			event: 'translate',
 			direction,
-			start,
-			stop
+			description: `${this.type} "${this.name}" sent signal on ${output}`,
+			event: 'output',
+			output: output
 		}
-		this.fire('translate', this.name, eventData);
+		this.fire('output', this.name, eventData);
+	}
 
-		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,
-			description: `output: ${stop}`,
-			event: 'output',
-			output: stop
+			direction,
+			description: `${this.type} "${this.name}" translated ${input} to ${output}`,
+			event: 'translate',
+			input, output
 		}
-		this.fire('output', this.name, eventData);
+		this.fire('translate', this.name, eventData);
+	}
+
+	/**
+	 *
+	 * @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);
 	}
 
 	/**

package/lib/enigma/Enigma.js

@@ -37,7 +37,7 @@ export default class Enigma extends Encoder {
 		/** @type {Encoder[]} */
 		this.encoders = [];
 		/**@type {SimplifiedConfiguration & {reflector: string}} */
-		this._configuration = {reflector}
+		this._configuration = {reflector, ringSettings: [], rotors: [], plugs: ''};
 	}
 
 	/**
@@ -107,13 +107,13 @@ export default class Enigma extends Encoder {
 
 		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() {
@@ -126,9 +126,10 @@ export default class Enigma extends Encoder {
 				/** @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,
-					description: `rotor ${rotor.name} double stepping from ${rotor.offset}`
 				}
 
 				this.fire('double-step', rotor.name, eventData);
@@ -166,8 +167,7 @@ export default class Enigma extends Encoder {
 			start = setup;
 		}
 
-		start = [...start].reverse();
-
+		start = [...start].reverse().join('');
 		// reset the rotation pending state
 		this.pending = {0: true};
 
@@ -190,7 +190,7 @@ export default class Enigma extends Encoder {
 		}
 
 		let connector = this.letterToConnector(letter);
-
+		this.fireInput(letter, "right");
 		this.step();
 
 		// encode to the right
@@ -210,7 +210,8 @@ export default class Enigma extends Encoder {
 
 		const outputLetter = this.connectorToLetter(connector);
 
-		this.fireEncodeSet(letter, outputLetter, "end-to-end")
+		this.fireOutput(outputLetter, "left");
+		this.fireTranslate(letter, outputLetter, "end-to-end");
 		return outputLetter;
 	}
 
@@ -222,7 +223,7 @@ export default class Enigma extends Encoder {
 	 *
 	 * @returns {String} the encoded string.
 	 */
-	encode(start, text) {
+	translate(start, text) {
 		this.setStart(start)
 		let letters = [...text];
 		let output = letters.map(function(letter) {

package/lib/enigma/EnigmaTypes.d.ts

@@ -20,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 */
@@ -121,16 +121,16 @@ type EventBase = {
  */
 type TranslateData = {
 	/** the event name */
-	event: EventName = "translate";
+	event: "translate";
 
 	/** the direction the signal was sent */
 	direction: Direction;
 
 	/** the starting value */
-	start: number | string;
+	input: number | string;
 
 	/** the translated value */
-	stop: number | string;
+	output: number | string;
 }
 
 /**
@@ -138,21 +138,20 @@ type TranslateData = {
  */
 type StepData = {
 	/** the event name */
-	event: EventName = "step";
+	event: "step";
 
 	/** the starting rotor position */
-	start: number | string;
+	start: number;
 
 	/** the ending rotor position */
-	stop: number | string
+	stop: number;
 
 	/** the locations of the turnover points for this rotor */
 	turnover: boolean;
 }
 
 type DoubleStepData = {
-	eventName: EventName = "double-step",
-	rotor: string;
+	event: "double-step",
 	offset: number;
 }
 
@@ -161,10 +160,13 @@ type DoubleStepData = {
  */
 type InputData = {
 	/** the event name */
-	event: EventName = "input";
+	event: "input";
 
 	/** the input connection */
 	input: number | string;
+
+	/** the direction the signal was sent */
+	direction: Direction;
 }
 
 /**
@@ -172,14 +174,17 @@ type InputData = {
  */
 type OutputData = {
 	/** the event name */
-	event: EventName = "output";
+	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);
+type EventData = EventBase & (TranslateData | StepData | InputData | OutputData | DoubleStepData);
 
 type Listener = (
 	/** name of the event being fired*/

package/lib/enigma/PlugBoard.js

@@ -57,7 +57,7 @@ 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

package/lib/enigma/Reflector.js

@@ -24,7 +24,7 @@ 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
 	 *

package/lib/enigma/Rotor.js

@@ -59,7 +59,7 @@ export default class Rotor extends Encoder {
 	 * connector for the rotor's zero point we need to adjust the connector
 	 * number for the current rotation.
 	 *
-	 * @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 connector in physical space
 	 *
@@ -97,12 +97,13 @@ export default class Rotor extends Encoder {
 
 		// turnover happens when we step past the turnover point
 		let turnover = this._turnovers.has(this.normalize(turnoverOffset - 1));
+		let turnoverStr = turnover ? 'with turnover' : ''
 
 		/** @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)}`,
+			description: `Rotor "${this.name}" stepped from ${start} to ${stop}${turnoverStr}`,
 			event: 'step',
 			turnover, start, stop
 		}

package/lib/enigma/index.js

@@ -1,5 +1,5 @@
 export {default as Enigma} from './Enigma.js';
-export {default as EntryDisc} from './EntryDisk.js';
+export {default as EntryDisc} from './EntryDisc.js';
 export {default as inventory} from './Inventory.js';
 export {default as PlugBoard} from './PlugBoard.js';
 export {default as Reflector} from './Rotor.js';

package/lib/enigma/tests/EnigmaSpec.js

@@ -21,7 +21,7 @@ describe('Enigma Test Cases', function() {
 			})
 
 			var toEncode = message.message[which]
-			var encoded = enigma.encode(message.message.key,toEncode);
+			var encoded = enigma.translate(message.message.key,toEncode);
 
 			return cb(message, encoded);
 		})
@@ -50,7 +50,7 @@ describe('Enigma Test Cases', function() {
 
 		it ('should step only the right-most rotor when not at turnover', function() {
 			steps = {};
-			enigma.encode('AAA', 'A');
+			enigma.translate('AAA', 'A');
 			var stepped = Object.keys(steps);
 			expect(stepped.length).toBe(1);
 			expect(stepped[0]).toBe('III');
@@ -58,13 +58,13 @@ describe('Enigma Test Cases', function() {
 
 		it ('should step the next rotor when the previous turns over', function() {
 			steps = {};
-			enigma.encode('AAV', 'A');
+			enigma.translate('AAV', 'A');
 			expect(steps['II'].length).toBe(1);
 		});
 
 		it ('should double step when reaching the turn over', function() {
 			steps = {};
-			enigma.encode('ADV', 'AA');
+			enigma.translate('ADV', 'AA');
 			expect(steps['II'].length).toBe(2);
 		});
 
@@ -75,7 +75,7 @@ describe('Enigma Test Cases', function() {
 
 			listen();
 
-			enigma.encode('UZV', 'AA');
+			enigma.translate('UZV', 'AA');
 			expect(steps['VI'].length).toBe(1);
 		});
 	})

package/lib/generator/CodeBook.js

@@ -108,11 +108,11 @@ export default class CodeBook {
 
 		let key = Random.choose(3, [...STANDARD_ALPHABET]).join('');
 		let start = Random.choose(3, [...STANDARD_ALPHABET]).join('');
-		let enc = this.enigma.encode(key, start);
+		let enc = this.enigma.translate(key, start);
 		let clear = text;
 
 		text = text.replace(/ /g, '');
-		text = this.enigma.encode(start, text);
+		text = this.enigma.translate(start, text);
 		text = this.generator.groupText(text);
 		text = paddedIndicator + ' ' + text
 
@@ -155,7 +155,7 @@ export default class CodeBook {
 		});
 
 		return {
-			options: this.enigma.configuration,
+			configuration: this.enigma.configuration,
 			parts: messages
 		}
 	}

package/lib/generator/Generator.js

@@ -109,9 +109,9 @@ export default class Generator {
 		let useRotors = structuredClone(setup.rotors || unfixed);
 		let rotors = Random.pick(3, useRotors);
 		let ringSettings = Random.choose(3, connectors);
-		let plugsList = Random.pickPairs(10, letters);
+		let plugsPairs = Random.pickPairs(10, letters);
 
-		plugsList = plugsList.map((pair) => pair.join(""));
+		let plugsList = plugsPairs.map((pair) => pair.join(""));
 
 		ringSettings[0]++;
 		ringSettings[1]++;
@@ -153,8 +153,9 @@ export default class Generator {
 		let decoded = this.cleanMessage(this.generateSentences(count));
 		let start = Random.choose(enigma.rotors.length, [...STANDARD_ALPHABET]).join('');
 
-		let encoded = enigma.encode(start, decoded);
+		let encoded = enigma.translate(start, decoded);
 
-		return {start, encoded, decoded, configuration: enigma.configuration};
+		return {start, encoded, decoded,
+			configuration: enigma.configuration};
 	}
 }

package/lib/generator/GeneratorTypes.d.ts

@@ -89,12 +89,13 @@ type GeneratedMessage = {
 	encoded: string;
 	/** the decoded string */
 	decoded: string;
+	configuration?: SimplifiedConfiguration;
 }
 
 type Model = ("I" | "M3" | "M4");
 
 type ModelOptions = {
 	rotors: string[];
-	fixed: string[];
+	fixed: string[] | boolean;
 	reflectors: string[];
 }

package/lib/utils/Random.js

@@ -147,7 +147,7 @@ class Random {
 	 * 	two items from the list
 	 */
 	pickPairs(count, list) {
-		/** @type {[T, T][]} */
+		/** @type {T[][]} */
 		let result = [];
 
 		for(let idx = 0; idx < count; idx++) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ondoher/enigma",
-  "version": "1.0.3",
-  "description": "Enigma machine simulator implementation with tools and documentation to help you build your own.",
+  "version": "1.0.6",
+  "description": "Enigma machine simulator with tools and documentation to help you build your own.",
   "main": "./lib/index.js",
   "scripts": {
     "test": "jasmine"
@@ -25,7 +25,12 @@
   "homepage": "https://github.com/Ondoher/enigma#readme",
   "type": "module",
   "devDependencies": {
+    "@types/node": "^25.0.10",
     "jasmine": "^4.5.0",
     "jasmine-console-reporter": "^3.1.0"
+  },
+  "dependencies": {
+    "@types/jasmine": "^4.6.6",
+    "undici-types": "^7.19.0"
   }
 }