@ondoher/enigma 0.1.7 → 1.0.0

package/jsconfig.json

@@ -0,0 +1,3 @@
+{
+
+}

package/lib/enigma/Encoder.js

@@ -1,20 +1,19 @@
 import { STANDARD_ALPHABET } from "./consts.js";
 
-/**
- * This is the listener for Enigma and component events
- * @callback Listener
- * @param {String} event a string that identifies the event being fired
- * @param {String} name the name of the component firing the event
- * @param {String} message a human readable description of the evebnt details
- * @param {Object} into event specific data for the event
- */
 
 /**
  * This is the base class for an encoder. The default implementation of the
  * encode method is to return the input as the output
  */
 export default class Encoder {
-	constructor(name, {cb, alphabet = STANDARD_ALPHABET}) {
+	/**
+	 * Constructor for the base encoder
+	 *
+	 * @param {string} name
+	 * @param {EncoderSetup} settings
+	 */
+	constructor(name, settings) {
+		let {cb, alphabet = STANDARD_ALPHABET} = settings;
 		this.name = name;
 		this.alphabet = alphabet;
 		this.contactCount = alphabet.length;
@@ -48,7 +47,7 @@ export default class Encoder {
 	}
 
 	/**
-	 * given an existing connection map from inoput to out put, create a new map
+	 * given an existing connection map from input to out put, create a new map
 	 * that has the connections going in the other direction, output to input.
 	 *
 	 * @param {Array.<Number>} map connection map
@@ -69,13 +68,13 @@ export default class Encoder {
 	 * the given direction The default encode method just passes the input value
 	 * through
 	 *
-	 * @param {String} direction either right for moving towards the reflector
+	 * @param {Direction} _direction either right for moving towards the reflector
 	 * 	or left if moving back
 	 * @param {Number} input the specific connection receiving an input
 	 *
 	 * @returns {Number} The translated output connector number
 	 */
-	encode(direction, input) {
+	encode(_direction, input) {
 		return input;
 	}
 
@@ -93,7 +92,7 @@ export default class Encoder {
 	 * Call this method to call the event listener
 	 *
 	 * @param {String} name the name of the event
-	 * @param  {...any} rest the parameters to pass to the callback
+	 * @param  {unknown[]} rest the parameters to pass to the callback
 	 */
 	fire(name, ...rest) {
 		if (this.cb) this.cb(name, ...rest);

package/lib/enigma/Enigma.js

@@ -4,40 +4,44 @@ import Rotor from "./Rotor.js";
 import Reflector from "./Reflector.js";
 import inventory from './Inventory.js'
 import { STANDARD_ALPHABET } from "./consts.js";
+import Encoder from "./Encoder.js";
 
 /**
  * Construct this class to get a new instance of the Enigma. Many of the
  * parameters to the constructor and the config method reference the names of
- * standard Enigma parts. These are retrived from the Inventory instance
+ * standard Enigma parts. These are retrieved from the Inventory instance
  */
 export default class Enigma {
 	/**
 	 * The constructor for the Enigma. This represents the unconfigurable
 	 * settings of the device.
 	 *
-	 * @param {Object} settings the settings for the Enigma
-	 * @property {String} [entryDisc] the name of entry disc in the inventory
-	 * this defaults 'default'
-	 * @param {String} reflector specifies one of possible reflectors, the
-	 * predefined reflectors are A, B, C, Thin-B and Thin-C
-	 * @param {String} [alphabet] the alphabet used by the system, usually just
-	 *	the uppercase latin letters
+	 * @param {EnigmaSetup} settings
 	 */
 	constructor(settings) {
-		var {entryDisc = 'default', reflector, alphabet = STANDARD_ALPHABET} = settings;
-		var entryDiscSettings = inventory.getEntryDisc(entryDisc)
+		let {entryDisc = 'default', reflector, alphabet = STANDARD_ALPHABET, model = "Enigma"} = settings;
+		let entryDiscSettings = inventory.getEntryDisc(entryDisc)
 
-		var reflectorSettings = inventory.getReflector(reflector)
+		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.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 currrent alphabet
+	 * the length of the current alphabet
 	 *
 	 * @param {Number} connector the number to be normalized
 	 *
@@ -50,43 +54,47 @@ export default class Enigma {
 		return connector;
 	}
 
+	/**
+	 * the configured rotors
+	 *
+	 * @return {Rotor[]}
+	 */
+	get rotors() {
+		return this._rotors;
+	}
+
+	/**
+	 * @returns {SimplifiedConfiguration & {reflector: string}}
+	 */
+	get configuration() {
+		return this._configuration;
+	}
+
 	/**
 	 * Configure the Enigma for encoding.
 	 *
-	 * @param {Object} settings the configuration of the Enigma. These settings
-	 * represent the aspects of the Enigma that can can change for daily
+	 * @param {EnigmaConfiguration} settings - the configuration of the Enigma.
+	 * These settings represent the aspects of the Enigma that can can change for daily
 	 * configuration.
-	 * @property {Array.<String>|String} [plugs] array of strings with each
-	 * 	element being a pair of letters from the alphabet that are being swapped
-	 * 	on the plug board
-	 * @property {Array.<String>} rotors the array of installed rotors. The
-	 * 	order here is signicant and is given in the left to right direction.
-	 * 	This means that last name in this list is the first rotor used in the
-	 * 	forward direction and last used in the backward direction. Each element
-	 * 	is the name of the rotor to use in the corresponding position. Stepping
-	 * 	stops at the first fixed rotor
-	 * @property {String|Array<Number>} [ringSettings] each letter in this
-	 * 	string represents the offset of the key settings from the rotor start
-	 * 	position. If it is an array, then each value is the one based key
-	 * 	setting for the related rotor,
 	 */
 	configure(settings) {
-		var { rotors, ringSettings = [], plugs = [] } = settings;
+		let { rotors, ringSettings = [], plugs = [] } = settings;
 
 		// make copies of these configurations so that we don't change the
 		// values from the caller, which in JavaScript are passed by reference.
-		rotors = JSON.parse(JSON.stringify(rotors));
-		ringSettings = JSON.parse(JSON.stringify(ringSettings));
+		let useRotors = structuredClone(rotors);
+		ringSettings = structuredClone(ringSettings);
 
 		// the rotors are given in the left to right direction, but are actually
 		// used in the right to left direction. So, here we reverse them
-		rotors = rotors.reverse();
+		useRotors = useRotors.reverse();
 
-		this.plugboard.configure({plugs})
+		this.plugboard.configure(plugs)
 
-		var ringOffsets = []
+		/** @type {number[]} */
+		let ringOffsets = []
 
-		// because the rotors are secified in the reverse other they are used,
+		// because the rotors are specified in the reverse other they are used,
 		// we have to do the same for the ringSettings.
 		if (Array.isArray(ringSettings)) {
 			ringSettings = ringSettings.reverse();
@@ -97,19 +105,25 @@ export default class Enigma {
 				ringOffsets.push(this.normalize(offset - 1))
 			}, this);
 		} else {
-			var letters = [...ringSettings];
+			let letters = [...ringSettings];
 			letters = letters.reverse();
 			letters.forEach(function(letter) {
-				var offset = this.alphabet.indexOf(letter);
+				let offset = this.alphabet.indexOf(letter);
 				ringOffsets.push(offset);
 			}, this)
 		}
 
-		this.rotors = rotors.map(function(name, idx) {
+		this._rotors = useRotors.map(function(name, idx) {
 			return new Rotor(`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,
+			plugs: this.plugboard.plugs
+		}
 	}
 
 	/**
@@ -117,7 +131,7 @@ export default class Enigma {
 	 * stepping between all rotors
 	 */
 	step() {
-		this.rotors.forEach(function(rotor, idx) {
+		this._rotors.forEach(function(rotor, idx) {
 			if (rotor.isFixed()) return;
 
 			// This is the double stepping. Only do this for the middle rotor
@@ -138,21 +152,25 @@ export default class Enigma {
 	/**
 	 * Call this method to set the starting rotation for the messages to encrypt
 	 *
-	 * @param {Array.Number>|String} the length of the string or the array
+	 * @param {number[]|string} setup - length of the string or the array
 	 * 	should match the number of rotors and are given left to right. If start
 	 * 	is a string then the letters of the string specify the start value seen
 	 * 	in the window for the corresponding rotor. If it is an array then each
 	 * 	number will be the one-based rotation.
 	 */
-	setStart(start) {
-		if (Array.isArray(start)) {
-			var charArray = start.map(function(number) {
+	setStart(setup) {
+		let start = '';
+		if (Array.isArray(setup)) {
+			let charArray = setup.map(function(number) {
 				number--;
 				return this.alphabet[number];
 			}, this);
 
 			start = charArray.join('');
+		} else {
+			start = setup;
 		}
+
 		start = [...start].reverse();
 
 		// reset the rotation pending state
@@ -168,13 +186,13 @@ export default class Enigma {
 	 * the encoded letter
 	 *
 	 * @param {String} letter the key pressed
-	 * @returns {String} the encoded letter
+	 * @returns {String | undefined} the encoded letter
 	 */
 	keyPress(letter) {
 		letter = letter.toUpperCase();
 		if (letter.length !== 1 || this.alphabet.indexOf(letter) === -1) {
 			if (letter !== ' ')
-				console.warn(`Unexected character ${letter}`);
+				console.warn(`Unexpected character ${letter}`);
 			return;
 		}
 
@@ -182,13 +200,13 @@ export default class Enigma {
 		this.step();
 
 		// encode to the right
-		var connector =  this.encoders.reduce(function(connector, encoder) {
+		let 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('', connector);
+		connector = this.reflector.encode('right', connector);
 
 		// encode to the left
 		connector = this.encoders.reduceRight(function(connector, encoder) {
@@ -204,15 +222,15 @@ export default class Enigma {
 	/**
 	 * Call this shortcut method to encode a whole string
 	 *
-	 * @param {String} start the starting positon for the rotors
+	 * @param {String} start the starting position for the rotors
 	 * @param {String} text the text to encode
 	 *
 	 * @returns {String} the encoded string.
 	 */
 	encode(start, text) {
 		this.setStart(start)
-		var letters = [...text];
-		var output = letters.map(function(letter) {
+		let letters = [...text];
+		let output = letters.map(function(letter) {
 			return this.keyPress(letter);
 		}, this)
 
@@ -222,7 +240,7 @@ export default class Enigma {
 	/**
 	 * Call this method to call the event listener
 	 *
-	 * @param {String} name the name of the event
+	 * @param {String} type the name of the event
 	 * @param  {...any} rest the parameters to pass to the callback
 	 */
 	fire(type, ...rest) {

package/lib/enigma/EnigmaTypes.d.ts

@@ -0,0 +1,101 @@
+// 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;
+
+interface EncoderSetup {
+	/** if specified defines an alternate alphabet for the enigma */
+	alphabet?: string;
+
+	/** if set, specifies a function to be called as the event listener */
+	cb?: Listener;
+
+	/** a string that defines the mapping between the input and output
+	 * connectors. The index into the string is the input connector and the
+	 * value of this string at that index is the output connector. For example,
+	 * 'YRUHQSLDPXNGOKMIEBFZCWVJAT' which is the map for standard reflector B. */
+	map?: string;
+}
+
+/**
+ * Defines how the enigma hardware is constructed. These are the settings that
+ * cannot be changed
+ */
+interface EnigmaSetup extends EncoderConfiguration {
+	/** which entry disc is part of the machine, defaults to "default" */
+	entryDisc?: string;
+	/** which reflector is part of the machine */
+	reflector: string;
+	/** Which alphabet is defined for the machine, defaults to A-Z */
+	alphabet?: string;
+	/** The name of the enigma model, defaults to the string "Enigma" */
+	model?: string;
+}
+
+/**
+ * Defines the setup of the plug configuration. It is wither an array of strings
+ * or a single string. If it is a string, it must be  a space separated list of
+ * letter pairs that connects one input letter to another. If it is an array
+ * then then each item is a pair of letters to specify how the plugs are connected
+ */
+type Plugs = string | string[];
+
+/**
+ * The configuration of the Enigma. These settings represent the aspects of the
+ * Enigma that can can change for daily configuration.
+ */
+type EnigmaConfiguration = {
+	/** defines how the plugs on the plugboard are configured. Defaults to no
+	 * plugs */
+	plugs?: Plugs;
+
+	/**
+	 * Array of installed rotors. The order here is significant and is given in
+	 * the left to right direction. 	This means that last name in this list
+	 * is the first rotor used in the forward direction and last used in the
+	 * backward direction. Each element is the name of the rotor to use in the
+	 * corresponding position. Stepping	stops at the first fixed rotor	 *
+	 */
+	rotors: string[];
+
+	/**
+	 * Specifies the setup of the ringSettings. This can specify as string of
+	 * letters or an array of numbers. Each letter in the string is used for the
+	 * rotor at that index. It's position in the alphabet is the offset for the
+	 * ring settings. If it is an array of number, each number is the one based
+	 * offset for the ring settings for the related rotor.
+	 */
+	ringSettings?: number[] | string;
+}
+
+/**
+ * Defines the setup of a Rotor. These are the unchangeable settings for the
+ * rotor
+ */
+interface RotorSetup extends EncoderSetup {
+	/** specifies how far forward to offset the outer ring relative to the
+	 * internal wiring. */
+	ringSetting?: number;
+	/** specifies the relative* location of where on the rotor turnover will
+	 * occur. The value is the what would be displayed in the window when
+	 * turnover happens, expressed as a character. The standard rotors VI-VIII,
+	 * available in the later model M3 had two turnover locations, M and Z.
+	 * Provide an empty string when the rotor does not rotate during stepping */
+	turnovers?: string;
+}
+
+type Direction = ("right"|"left")

package/lib/enigma/EntryDisc.js

@@ -1,5 +1,5 @@
+import { STANDARD_ALPHABET } from './consts.js';
 import Encoder from './Encoder.js';
-import { STANDARD_ALPHABET } from "./consts.js";
 
 
 /**
@@ -8,19 +8,27 @@ import { STANDARD_ALPHABET } from "./consts.js";
  */
 export default class EntryDisc extends Encoder {
 	/**
-	 * Constuctor for the entry disc.
+	 * Constructor for the entry disc.
 	 *
-	 * @param {String} name thge name of this entry disc
-	 * @param {Object} settings contains the alphabet being used, and the map
+	 * @param {String} name the name of this entry disc
+	 * @param {EncoderSetup} settings contains the alphabet being used, and the map
 	 * 	between input and output contacts
 	 */
 	constructor(name, settings) {
 		super(name, settings);
-		var {map} = settings;
+		var {map = STANDARD_ALPHABET} = settings;
 		this.rightMap = this.makeMap(map);
 		this.leftMap = this.makeReverseMap(this.rightMap);
 	}
 
+	/**
+	 *
+	 * @param {Direction} direction either right for moving towards the reflector
+	 * 	or left if moving back
+	 * @param {Number} input the specific connection receiving an input
+	 *
+	 * @returns {Number} The translated output connector number
+	 */
 	encode(direction, input) {
 		var result = direction === 'right' ? this.rightMap[input]: this.leftMap[input];
 		var evName = direction === 'right' ? 'encode-right' : 'encode-left';

package/lib/enigma/Inventory.js

@@ -1,5 +1,5 @@
 /**
- * This is the class used to manage the standard inmventory of components. An
+ * This is the class used to manage the standard inventory of components. An
  * instance of this class is exported as the default of this module
  */
 
@@ -9,8 +9,8 @@ class Inventory {
 	 */
 	constructor() {
 		this.entryDiscs = {};
+		/** @type {{[name: string]: RouterInventorySpec}}*/
 		this.rotors = {};
-		this.fixedRotors = {};
 		this.reflectors = {};
 	}
 
@@ -69,7 +69,7 @@ class Inventory {
 	 * @param {String} name the name of the rotor as it was added to the
 	 * 	inventory.
 	 *
-	 * @returns {Object} the rotor defintion
+	 * @returns {Object} the rotor definition
 	 * @property {String} map the connection map for the rotor
 	 * @property {String} turnovers the locations where turnovers happen
 	 */
@@ -104,10 +104,30 @@ class Inventory {
 	/**
 	 * Call this method to get the names of all the rotors in the inventory
 	 *
-	 * @returns {Array.<String>} the names of the rotors
+	 * @param {boolean} [fixed] - if specified it returns only the names of
+	 * routers filtered on if they are fixed or not, otherwise it returns all
+	 *
+	 * @returns {string[]} the names of the rotors
 	 */
-	getRotorNames() {
-		return Object.keys(this.rotors);
+	getRotorNames(fixed) {
+		if (fixed === undefined) {
+			return Object.keys(this.rotors);
+		}
+
+		let entries = Object.entries(this.rotors);
+
+		entries = entries.filter(([_name, rotor]) => {
+			if (rotor.turnovers === '' && fixed) {
+				return true;
+			}
+			if (rotor.turnovers !== '' && !fixed) {
+				return true;
+			}
+
+			return false;
+		})
+
+		return entries.map(([name, _router]) => name);
 	}
 }
 

package/lib/enigma/PlugBoard.js

@@ -10,7 +10,7 @@ export default class PlugBoard extends Encoder {
 	 * Constructor for the plugboard.
 	 *
 	 * @param {String} name the name for the plugboard, defaults to 'plugboard'
-	 * @param {Object} [settings] the settings for the plugboard. Only needed if
+	 * @param {EncoderSetup} [settings] the settings for the plugboard. Only needed if
 	 * 	using an alternate alphabet
 	 */
 	constructor(name = 'plugboard', settings = {}) {
@@ -19,36 +19,38 @@ export default class PlugBoard extends Encoder {
 		var {alphabet = STANDARD_ALPHABET, map} = settings;
 		this.alphabet = alphabet;
 		this.map = map || alphabet;
+		this.rightMap = [];
+		this.leftMap = [];
+		this.plugs = '';
 	}
 
 	/**
 	 * Call this method to configure the plug board. This will be used to
 	 * provide the plug connections
 	 *
-	 * @param {Object} [settings] the configuration options for the plug
+	 * @param {Plugs} plugs the configuration options for the plug
 	 * 	board
-	 * @property {Array.<String>|String} [plugs] either an array of strings or a
-	 * 	single string. If it is a string, it must be a space separated list of
-	 * 	letter pairs that connects one input letter to another. If it is an
-	 * array then then each item is a pair of letters to specify how the plugs
-	 * are connected
 	 */
-	configure(settings = {}) {
-		var map = this.map;
-		var {plugs = []} = settings;
+	configure(plugs = []) {
+		let map = this.map;
+		/** @type {string[]} */
 
-		if (typeof plugs === 'string') plugs = plugs.split(' ');
-		plugs.forEach(function(plug) {
-			var firstIdx = this.alphabet.indexOf(plug[0]);
-			var secondIdx = this.alphabet.indexOf(plug[1]);
-			var first = map[firstIdx];
-			var second = map[secondIdx];
+		if (typeof plugs === 'string') {
+			plugs = plugs.split(' ');
+		}
+		plugs.forEach((plug) => {
+			let firstIdx = this.alphabet.indexOf(plug[0]);
+			let secondIdx = this.alphabet.indexOf(plug[1]);
+			let first = map[firstIdx];
+			let second = map[secondIdx];
 			map = map.slice(0, firstIdx) + second + map.slice(firstIdx + 1);
 			map = map.slice(0, secondIdx) + first + map.slice(secondIdx + 1);
-		}, this)
+		})
 
 		this.rightMap = this.makeMap(map);
 		this.leftMap = this.makeReverseMap(this.rightMap);
+
+		this.plugs = plugs.join(' ');
 	}
 
 	/**
@@ -69,6 +71,7 @@ export default class PlugBoard extends Encoder {
 				output: result,
 			}
 		);
+
 		return result;
 	}
 }

package/lib/enigma/Reflector.js

@@ -10,18 +10,11 @@ export default class Reflector extends Encoder {
 	 * constructor for the reflector class.
 	 *
 	 * @param {String} name the name of the reflector instance
-	 * @param {Obect} The definition of the reflector
-	 * @property {String} [alphabet] a string of letters that are an alternative
-	 * 	to the standard A-Z. Defaults to A-Z
-	 * @property {String} map a string that defines the mapping between the
-	 * input and output connectors. The index into the string is the input
-	 * connector and the value of this string at that index is the output
-	 * connector. For example, 'YRUHQSLDPXNGOKMIEBFZCWVJAT' which is the map for
-	 * standard reflector B.
+	 * @param {EncoderSetup} settings The definition of the reflector
 	 */
 	constructor(name, settings) {
 		super(name, settings);
-		var {map} = settings;
+		var {map = STANDARD_ALPHABET} = settings;
 
  		this.map = this.makeMap(map);
 	}
@@ -31,13 +24,13 @@ 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 {String} 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}`,