@ondoher/enigma 1.0.2 → 1.0.5

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "outFile": "./dist/index.d.ts",
+    "module": "AMD",
+    "target": "es2020",
+    "allowJs": true,           /* Allow JavaScript files to be compiled. */
+    "checkJs": true,           /* Report errors in .js files. */
+    "declaration": true,       /* Generate .d.ts files for JS files. */
+    "emitDeclarationOnly": true, /* Only emit .d.ts files, not the source .js files. */
+    "outDir": "./types",        /* Redirect output to the 'types' folder. */
+	"paths": {
+      "undici-types": [
+        "./node_modules/undici-types/index.d.ts"
+      ]
+	}
+  },
+  "include": ["lib/**/*.js", "lib/**/*.d.ts"],   /* Specify which JS files to include (e.g., in a 'src' directory). */
+  "exclude": ["node_modules"],   /* Exclude standard folders. */
+}

package/types/enigma/Encoder.d.ts

@@ -0,0 +1,128 @@
+/**
+ * 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 for the base encoder
+     *
+     * @param {string} name
+     * @param {ComponentType} type
+     * @param {EncoderSetup} settings
+     */
+    constructor(name: string, type: ComponentType, settings: EncoderSetup);
+    name: string;
+    type: ComponentType;
+    alphabet: string;
+    contactCount: number;
+    /** @type {{[name: string]: Listener}} */
+    listeners: {
+        [name: string]: Listener;
+    };
+    /**
+     * given a connector number, normalize it to be between 0 and 25 inclusive.
+     *
+     * @param {Number} connector the connector being normalized
+     *
+     * @returns {Number} value between 0 and 25
+     */
+    normalize(connector: number): number;
+    /**
+     *
+     * @param {string} letter
+     *
+     * @returns {boolean}
+     */
+    verifyLetter(letter: string): boolean;
+    /**
+     * Call this method to convert a letter to a connector value
+     *
+     * @param {string} letter
+     * @returns {number | undefined}
+     */
+    letterToConnector(letter: string): number | undefined;
+    /**
+     * Call this method to turn a connector to a letter value
+     *
+     * @param {number} connector
+     * @returns {string | undefined}
+     */
+    connectorToLetter(connector: number): string | undefined;
+    /**
+     * Given an alphabetic connection map, convert that into an array of
+     * numbers. The index into the array or string is the input connector, and
+     * the value at that position is the output connector
+     *
+     * @param {String} map connections map.
+     * @returns {Array.<Number>} the numerical map
+     */
+    makeMap(map: string): Array<number>;
+    /**
+     * 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
+     * @returns {Array.<Number>} the reversed map
+     */
+    makeReverseMap(map: Array<number>): Array<number>;
+    /**
+     * Call this method to convert the input connector number to the output in
+     * the given direction The default encode method just passes the input value
+     * through
+     *
+     * @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: Direction, input: number): number;
+    /**
+     *
+     * @param {number | string} input
+     * @param {Direction} direction
+     */
+    fireInput(input: number | string, direction: Direction): void;
+    /**
+     *
+     * @param {number | string} output
+     * @param {Direction} direction
+     */
+    fireOutput(output: number | string, direction: Direction): void;
+    /**
+     *
+     * @param {number | string} input
+     * @param {number | string} output
+     * @param {Direction} direction
+     */
+    fireTranslate(input: number | string, output: number | string, direction: Direction): void;
+    /**
+     *
+     * @param {number | string} input
+     * @param {number | string} output
+     * @param {Direction} direction
+     */
+    fireEncodeSet(input: number | string, output: number | string, direction: Direction): void;
+    /**
+     * 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: string, cb: Listener): void;
+    /**
+     * Call this method to remove a listener
+     *
+     * @param {string} name - the name of the listener
+     */
+    unlisten(name: string): void;
+    /**
+     * Call this method to call any event listeners
+     *
+     * @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(event: EventName, name: string, data: EventData): void;
+}

package/types/enigma/Enigma.d.ts

@@ -0,0 +1,88 @@
+/**
+ * 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 retrieved from the Inventory instance
+ */
+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(name: string, settings: EnigmaSetup);
+    plugboard: PlugBoard;
+    entryDisc: EntryDisc;
+    reflector: Reflector;
+    length: number;
+    /** @type {Rotor[]} */
+    _rotors: Rotor[];
+    /** @type {{[rotor: number]: boolean}} */
+    pending: {
+        [rotor: number]: boolean;
+    };
+    /** @type {Encoder[]} */
+    encoders: Encoder[];
+    /**@type {SimplifiedConfiguration & {reflector: string}} */
+    _configuration: SimplifiedConfiguration & {
+        reflector: string;
+    };
+    /**
+     * the configured rotors
+     *
+     * @return {Rotor[]}
+     */
+    get rotors(): Rotor[];
+    /**
+     * @returns {SimplifiedConfiguration & {reflector: string}}
+     */
+    get configuration(): SimplifiedConfiguration & {
+        reflector: string;
+    };
+    /**
+     * Configure the Enigma for encoding.
+     *
+     * @param {EnigmaConfiguration} settings - the configuration of the Enigma.
+     * These settings represent the aspects of the Enigma that can can change for daily
+     * configuration.
+     */
+    configure(settings: EnigmaConfiguration): void;
+    /**
+     * Call this method to "step" the rotors one time. This method will manage the
+     * stepping between all rotors
+     */
+    step(): void;
+    /**
+     * Call this method to set the starting rotation for the messages to encrypt
+     *
+     * @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(setup: number[] | string): void;
+    /**
+     * Call this method to simulate a keypress on the Enigma. This will output
+     * the encoded letter
+     *
+     * @param {String} letter the key pressed
+     * @returns {String | undefined} the encoded letter
+     */
+    keyPress(letter: string): string | undefined;
+    /**
+     * Call this shortcut method to encode a whole string
+     *
+     * @param {String} start the starting position for the rotors
+     * @param {String} text the text to encode
+     *
+     * @returns {String} the encoded string.
+     */
+    translate(start: string, text: string): string;
+}
+import Encoder from "./Encoder.js";
+import PlugBoard from "./PlugBoard.js";
+import EntryDisc from "./EntryDisc.js";
+import Reflector from "./Reflector.js";
+import Rotor from "./Rotor.js";

package/types/enigma/EntryDisc.d.ts

@@ -0,0 +1,17 @@
+/**
+ * This is the class for an entry disc. Entry discs are fixed disks of connector
+ * pins.
+ */
+export default class EntryDisc extends Encoder {
+    /**
+     * Constructor for the entry disc.
+     *
+     * @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: string, settings: EncoderSetup);
+    rightMap: number[];
+    leftMap: number[];
+}
+import Encoder from './Encoder.js';

package/types/enigma/Inventory.d.ts

@@ -0,0 +1,91 @@
+declare const _default: Inventory;
+export default _default;
+/**
+ * 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
+ */
+declare class Inventory {
+    entryDiscs: {};
+    /** @type {{[name: string]: RouterInventorySpec}}*/
+    rotors: {
+        [name: string]: RouterInventorySpec;
+    };
+    reflectors: {};
+    /**
+     * Call this method to add a new Rotor type to the inventory.
+     *
+     * @param {String} name the name of the rotor being added. This name will be
+     * 	used when specifying the rotors to use for the Enigma configuration.
+     * @param {String} map a string specifying the connector mapping. The index
+     * 	of the string is the logical coordinate of the connector, the character
+     * 	at that index is the output connector. To be exact, it would be the
+     * 	position of that character in the given alphabet. So, in the map '
+     * 	EKMFLGDQVZNTOWYHXUSPAIBRCJ', input connector 0 would map to output
+     * 	connector 4 and input connector 1 would map to output connector 10.
+     * 	Remember that the connectors are numbered starting at 0.
+     * @param {String} turnovers this is a string of characters representing the
+     * 	turnover locations on the disk. These letter would be the value shown in
+     * 	the window to during turnover. In Rotor I this is 'Q' in rotors VI, VII,
+     * 	and VIII there are two turnover locations, 'M' and 'Z'. Pass an empty
+     * 	string if this is a fixed rotor
+     */
+    addRotor(name: string, map: string, turnovers: string): void;
+    /**
+     * Call this method to add a new reflector definition.
+     *
+     * @param {String} name this is the name that will be used to reference this
+     * 	reflector when constructing an Enigma class.
+     * @param {String} map the mapping between connectors. this uses the same
+     * 	format used in the addRotor method
+     */
+    addReflector(name: string, map: string): void;
+    /**
+     * Call this method to add a new entry disc. There was only one used in the
+     * standard military models, but there were other versions that defined it
+     * differently.
+     *
+     * @param {*} name this is the name that will be used to reference this
+     * 	entry disc when constructing an Enigma class.
+     * @param {*} map the mapping between connectors. this uses the same format
+     * 	used in the addRotor method
+     */
+    addEntryDisc(name: any, map: any): void;
+    /**
+     * Call this method to get the setup for a defined rotor.
+     *
+     * @param {String} name the name of the rotor as it was added to the
+     * 	inventory.
+     *
+     * @returns {Object} the rotor definition
+     * @property {String} map the connection map for the rotor
+     * @property {String} turnovers the locations where turnovers happen
+     */
+    getRotor(name: string): any;
+    /**
+     * Call this method to get the setup for a defined reflector.
+     *
+     * @param {String} name the name of the reflector as it was added to the
+     * 	inventory.
+     * @returns {Object} the reflector definition
+     * @property {String} the connection map for the reflector
+     */
+    getReflector(name: string): any;
+    /**
+     * Call this method to get the setup for a defined entry disc.
+     *
+     * @param {String} name the name of the entry disc as it was added to the
+     * 	inventory.
+     * @returns {Object} the entry disc definition
+     * @property {String} the connection map for the entry disc
+     */
+    getEntryDisc(name: string): any;
+    /**
+     * Call this method to get the names of all the rotors in the inventory
+     *
+     * @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(fixed?: boolean): string[];
+}

package/types/enigma/PlugBoard.d.ts

@@ -0,0 +1,26 @@
+/**
+ * This class represents the plugboard. There is only one type of plugboard
+ */
+export default class PlugBoard extends Encoder {
+    /**
+     * Constructor for the plugboard.
+     *
+     * @param {String} name the name for the plugboard, defaults to 'plugboard'
+     * @param {EncoderSetup} [settings] the settings for the plugboard. Only needed if
+     * 	using an alternate alphabet
+     */
+    constructor(name?: string, settings?: EncoderSetup);
+    map: string;
+    rightMap: any[];
+    leftMap: any[];
+    plugs: string;
+    /**
+     * Call this method to configure the plug board. This will be used to
+     * provide the plug connections
+     *
+     * @param {Plugs} plugs the configuration options for the plug
+     * 	board
+     */
+    configure(plugs?: Plugs): void;
+}
+import Encoder from "./Encoder.js";

package/types/enigma/Reflector.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Make in instance of this class to construct a reflector
+ */
+export default class Reflector extends Encoder {
+    /**
+     * constructor for the reflector class.
+     *
+     * @param {String} name the name of the reflector instance
+     * @param {EncoderSetup} settings The definition of the reflector
+     */
+    constructor(name: string, settings: EncoderSetup);
+    map: number[];
+}
+import Encoder from './Encoder.js';

package/types/enigma/Rotor.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Create an instance of this class to construct a Rotor object. The Rotor class
+ * encapsulates many of the peculiar behaviors of the Enigma. All connector
+ * values here are specified in physical space.
+ */
+export default class Rotor extends Encoder {
+    /**
+     * This is the constructor for the rotor.
+     *
+     * @param {String} name the name of the rotor; under normal circumstances
+     * 	this will be the string 'rotor-' plus the standard name for the rotor,
+        * for example 'rotor-IV'
+     * @param {RotorSetup} settings an object that contains the various options that
+     * define the the rotor and how it is configured.
+     */
+    constructor(name: string, settings: RotorSetup);
+    map: string[];
+    rightMap: number[];
+    leftMap: number[];
+    length: number;
+    ringOffset: number;
+    turnoverLookup: number[];
+    offset: number;
+    fixed: boolean;
+    turnovers: string;
+    _turnovers: Set<number>;
+    /**
+     * Call this method to select the initial rotation of the rotor. This is a
+     * letter offset from the logical 0 connector. The initial rotation will
+     * also take into account the ring setting
+     *
+     * @param {String} connector This is a letter value that corresponds to what
+     * would appear in the rotation window. This value will be adjusted for the
+     * ring setting.
+     */
+    setStartPosition(connector: string): void;
+    /**
+     * Call this method to step the rotor
+     *
+     * @returns {Boolean} true if the next rotor should be stepped
+     */
+    step(): boolean;
+    /**
+     * Call this method to see if the next step on this rotor will lead to
+     * turnover. The Enigma class will call this on the middle rotor to handle
+     * double stepping.
+     *
+     * @returns true if this rotor will turnover on the next step
+     */
+    willTurnover(): boolean;
+    shouldTurnover(): boolean;
+    /**
+     * Call this method to find whether this is a fixed rotor. This is used for
+     * the non stepping rotors--beta and gamma--that are used in the M4
+     * @returns
+     */
+    isFixed(): boolean;
+}
+import Encoder from "./Encoder.js";

package/types/enigma/consts.d.ts

@@ -0,0 +1 @@
+export const STANDARD_ALPHABET: string;

package/types/enigma/index.d.ts

@@ -0,0 +1,5 @@
+export { default as Enigma } from "./Enigma.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/types/enigma/standardInventory.d.ts

@@ -0,0 +1,71 @@
+export namespace entryDiscDefinitions {
+    let _default: string;
+    export { _default as default };
+}
+export namespace rotorDefinitions {
+    namespace I {
+        let map: string;
+        let turnovers: string;
+    }
+    namespace II {
+        let map_1: string;
+        export { map_1 as map };
+        let turnovers_1: string;
+        export { turnovers_1 as turnovers };
+    }
+    namespace III {
+        let map_2: string;
+        export { map_2 as map };
+        let turnovers_2: string;
+        export { turnovers_2 as turnovers };
+    }
+    namespace IV {
+        let map_3: string;
+        export { map_3 as map };
+        let turnovers_3: string;
+        export { turnovers_3 as turnovers };
+    }
+    namespace V {
+        let map_4: string;
+        export { map_4 as map };
+        let turnovers_4: string;
+        export { turnovers_4 as turnovers };
+    }
+    namespace VI {
+        let map_5: string;
+        export { map_5 as map };
+        let turnovers_5: string;
+        export { turnovers_5 as turnovers };
+    }
+    namespace VII {
+        let map_6: string;
+        export { map_6 as map };
+        let turnovers_6: string;
+        export { turnovers_6 as turnovers };
+    }
+    namespace VIII {
+        let map_7: string;
+        export { map_7 as map };
+        let turnovers_7: string;
+        export { turnovers_7 as turnovers };
+    }
+    namespace Beta {
+        let map_8: string;
+        export { map_8 as map };
+        let turnovers_8: string;
+        export { turnovers_8 as turnovers };
+    }
+    namespace Gamma {
+        let map_9: string;
+        export { map_9 as map };
+        let turnovers_9: string;
+        export { turnovers_9 as turnovers };
+    }
+}
+export const reflectorDefinitions: {
+    A: string;
+    B: string;
+    C: string;
+    'Thin-B': string;
+    'Thin-C': string;
+};

package/types/enigma/tests/EnigmaData.d.ts

@@ -0,0 +1,46 @@
+export namespace enigmaData {
+    let sampleFieldMessages: ({
+        source: string;
+        model: string;
+        setup: {
+            reflector: string;
+            rotors: string[];
+            ringSettings: number[];
+            plugs: string;
+        };
+        message: {
+            key: string;
+            encoded: string;
+            decoded: string;
+        };
+    } | {
+        source: string;
+        model: string;
+        setup: {
+            reflector: string;
+            rotors: string[];
+            ringSettings: string;
+            plugs: string;
+        };
+        message: {
+            key: string;
+            encoded: string;
+            decoded: string;
+        };
+    })[];
+    let sampleVerifiedMessages: {
+        verified: string[];
+        model: string;
+        setup: {
+            rotors: string[];
+            plugs: string;
+            ringSettings: number[];
+            reflector: string;
+        };
+        message: {
+            key: string;
+            encoded: string;
+            decoded: string;
+        };
+    }[];
+}

package/types/enigma/tests/EnigmaSpec.d.ts

@@ -0,0 +1 @@
+export {};

package/types/enigma/tests/PlugBoardData.d.ts

@@ -0,0 +1,4 @@
+export namespace plugBoardData {
+    let alphabet: string;
+    let plugSettings: string;
+}

package/types/enigma/tests/PlugBoardSpec.d.ts

@@ -0,0 +1 @@
+export {};

package/types/enigma/tests/RotorData.d.ts

@@ -0,0 +1,15 @@
+export namespace rotorData {
+    namespace createData {
+        let alphabet: string;
+        let map: string;
+        let reverseMap: number[];
+        let turnovers: string;
+        let turnoversMap: number[];
+    }
+    namespace I {
+        let map_1: string;
+        export { map_1 as map };
+        let turnovers_1: string;
+        export { turnovers_1 as turnovers };
+    }
+}

package/types/enigma/tests/RotorSpec.d.ts

@@ -0,0 +1 @@
+export {};