jssm 5.112.3 → 5.113.0

package/dist/es6/jssm_constants.js

@@ -1,121 +0,0 @@
-/*******
- *
- *  Convenience aliases for common mathematical and numeric constants from
- *  `Number` and `Math`.  Re-exported so that FSL data expressions and tests
- *  can reference them without importing `Math` directly.
- *
- *  Includes: `NegInfinity`, `PosInfinity`, `Epsilon`, `Pi`, `E`, `Root2`,
- *  `RootHalf`, `Ln2`, `Ln10`, `Log2E`, `Log10E`, `MaxSafeInt`, `MinSafeInt`,
- *  `MaxPosNum`, `MinPosNum`, `Phi` (golden ratio), `EulerC` (Euler–Mascheroni).
- *
- */
-export const NegInfinity = Number.NEGATIVE_INFINITY, PosInfinity = Number.POSITIVE_INFINITY, Epsilon = Number.EPSILON, Pi = Math.PI, E = Math.E, Root2 = Math.SQRT2, RootHalf = Math.SQRT1_2, Ln2 = Math.LN2, Ln10 = Math.LN10, Log2E = Math.LOG2E, Log10E = Math.LOG10E, MaxSafeInt = Number.MAX_SAFE_INTEGER, MinSafeInt = Number.MIN_SAFE_INTEGER, MaxPosNum = Number.MAX_VALUE, MinPosNum = Number.MIN_VALUE, Phi = 1.61803398874989484820, EulerC = 0.57721566490153286060;
-/*******
- *
- *  Complete list of node shapes supported by Graphviz.  Used by jssm-viz to
- *  validate and render state shapes in FSL `state ... : { shape: ... }` blocks.
- *
- *  `shapes` is an alias for `gviz_shapes`.
- *
- */
-const gviz_shapes = [
-    "box3d",
-    "polygon",
-    "ellipse",
-    "oval",
-    "circle",
-    "point",
-    "egg",
-    "triangle",
-    "plaintext",
-    "plain",
-    "diamond",
-    "trapezium",
-    "parallelogram",
-    "house",
-    "pentagon",
-    "hexagon",
-    "septagon",
-    "octagon",
-    "doublecircle",
-    "doubleoctagon",
-    "tripleoctagon",
-    "invtriangle",
-    "invtrapezium",
-    "invhouse",
-    "Mdiamond",
-    "Msquare",
-    "Mcircle",
-    "rectangle",
-    "rect",
-    "square",
-    "star",
-    "none",
-    "underline",
-    "cylinder",
-    "note",
-    "tab",
-    "folder",
-    "box",
-    "component",
-    "promoter",
-    "cds",
-    "terminator",
-    "utr",
-    "primersite",
-    "restrictionsite",
-    "fivepoverhang",
-    "threepoverhang",
-    "noverhang",
-    "assembly",
-    "signature",
-    "insulator",
-    "ribosite",
-    "rnastab",
-    "proteasesite",
-    "proteinstab",
-    "rpromoter",
-    "rarrow",
-    "larrow",
-    "lpromoter",
-    "record"
-];
-const shapes = gviz_shapes;
-/*******
- *
- *  List of CSS/SVG named colors accepted by jssm-viz for state styling
- *  properties like `background-color` and `text-color`.  Case-insensitive
- *  matching is done at parse time; the canonical casing here follows the
- *  CSS specification.
- *
- */
-const named_colors = [
-    "AliceBlue", "AntiqueWhite", "Aqua", "Aquamarine", "Azure", "Beige",
-    "Bisque", "Black", "BlanchedAlmond", "Blue", "BlueViolet", "Brown",
-    "BurlyWood", "CadetBlue", "Chartreuse", "Chocolate", "Coral",
-    "CornflowerBlue", "Cornsilk", "Crimson", "Cyan", "DarkBlue", "DarkCyan",
-    "DarkGoldenRod", "DarkGray", "DarkGrey", "DarkGreen", "DarkKhaki",
-    "DarkMagenta", "DarkOliveGreen", "Darkorange", "DarkOrchid", "DarkRed",
-    "DarkSalmon", "DarkSeaGreen", "DarkSlateBlue", "DarkSlateGray",
-    "DarkSlateGrey", "DarkTurquoise", "DarkViolet", "DeepPink", "DeepSkyBlue",
-    "DimGray", "DimGrey", "DodgerBlue", "FireBrick", "FloralWhite", "ForestGreen",
-    "Fuchsia", "Gainsboro", "GhostWhite", "Gold", "GoldenRod", "Gray", "Grey",
-    "Green", "GreenYellow", "HoneyDew", "HotPink", "IndianRed", "Indigo", "Ivory",
-    "Khaki", "Lavender", "LavenderBlush", "LawnGreen", "LemonChiffon",
-    "LightBlue", "LightCoral", "LightCyan", "LightGoldenRodYellow", "LightGray",
-    "LightGrey", "LightGreen", "LightPink", "LightSalmon", "LightSeaGreen",
-    "LightSkyBlue", "LightSlateGray", "LightSlateGrey", "LightSteelBlue",
-    "LightYellow", "Lime", "LimeGreen", "Linen", "Magenta", "Maroon",
-    "MediumAquaMarine", "MediumBlue", "MediumOrchid", "MediumPurple",
-    "MediumSeaGreen", "MediumSlateBlue", "MediumSpringGreen", "MediumTurquoise",
-    "MediumVioletRed", "MidnightBlue", "MintCream", "MistyRose", "Moccasin",
-    "NavajoWhite", "Navy", "OldLace", "Olive", "OliveDrab", "Orange", "OrangeRed",
-    "Orchid", "PaleGoldenRod", "PaleGreen", "PaleTurquoise", "PaleVioletRed",
-    "PapayaWhip", "PeachPuff", "Peru", "Pink", "Plum", "PowderBlue", "Purple",
-    "Red", "RosyBrown", "RoyalBlue", "SaddleBrown", "Salmon", "SandyBrown",
-    "SeaGreen", "SeaShell", "Sienna", "Silver", "SkyBlue", "SlateBlue",
-    "SlateGray", "SlateGrey", "Snow", "SpringGreen", "SteelBlue", "Tan", "Teal",
-    "Thistle", "Tomato", "Turquoise", "Violet", "Wheat", "White", "WhiteSmoke",
-    "Yellow", "YellowGreen"
-];
-export { gviz_shapes, shapes, named_colors, };

package/dist/es6/jssm_error.js

@@ -1,47 +0,0 @@
-/*******
- *
- *  Custom error class for jssm.  Enriches the standard `Error` with
- *  machine context (current state, instance name) and an optional
- *  `requested_state` so that error messages are self-describing.
- *
- *  ```typescript
- *  throw new JssmError(machine, 'no such state', { requested_state: 'Blue' });
- *  // JssmError: [[my-light]]: no such state (at "Red", requested "Blue")
- *  ```
- *
- *  @param machine         - The `Machine` instance that raised the error, or
- *                           `undefined` if no machine is available.  Used to
- *                           read `state()` and `instance_name()` for context.
- *  @param message         - A human-readable description of the error.
- *  @param JEEI            - Optional {@link JssmErrorExtendedInfo} with extra
- *                           context such as `requested_state`.
- *
- */
-class JssmError extends Error {
-    constructor(machine, message, JEEI) {
-        const { requested_state } = (JEEI === undefined)
-            ? { requested_state: undefined }
-            : JEEI;
-        const follow_ups = [];
-        if (machine) {
-            if (machine.state() !== undefined) {
-                follow_ups.push(`at "${machine.state()}"`);
-            }
-        }
-        if (requested_state !== undefined) {
-            follow_ups.push(`requested "${requested_state}"`);
-        }
-        const complex_msg = `${((machine === null || machine === void 0 ? void 0 : machine.instance_name()) !== undefined)
-            ? `[[${machine.instance_name()}]]: `
-            : ''}${message}${follow_ups.length
-            ? ` (${follow_ups.join(', ')})`
-            : ''}`;
-        super(complex_msg);
-        this.name = 'JssmError';
-        this.message = complex_msg;
-        this.base_message = message;
-        this.requested_state = requested_state;
-    }
-}
-;
-export { JssmError };

package/dist/es6/jssm_theme.js

@@ -1,24 +0,0 @@
-import { base_theme } from './themes/jssm_base_stylesheet';
-import { default_theme } from './themes/jssm_theme_default';
-import { modern_theme } from './themes/jssm_theme_modern';
-import { ocean_theme } from './themes/jssm_theme_ocean';
-import { plain_theme } from './themes/jssm_theme_plain';
-import { bold_theme } from './themes/jssm_theme_bold';
-/*******
- *
- *  Registry mapping theme names to their stylesheet definitions.  Each entry
- *  maps an {@link FslTheme} string (e.g. `'default'`, `'ocean'`) to a
- *  {@link JssmBaseTheme} object containing colors, shapes, and other visual
- *  defaults used by jssm-viz when rendering state machine diagrams.
- *
- *  Add new themes by importing their definition and calling
- *  `theme_mapping.set(name, theme)`.
- *
- */
-const theme_mapping = new Map();
-theme_mapping.set('default', default_theme);
-theme_mapping.set('modern', modern_theme);
-theme_mapping.set('ocean', ocean_theme);
-theme_mapping.set('plain', plain_theme);
-theme_mapping.set('bold', bold_theme);
-export { theme_mapping, base_theme };

package/dist/es6/jssm_types.js

@@ -1,3 +0,0 @@
-const FslDirections = ['up', 'right', 'down', 'left'];
-const FslThemes = ['default', 'ocean', 'modern', 'plain', 'bold'];
-export { FslDirections, FslThemes };

package/dist/es6/jssm_util.js

@@ -1,337 +0,0 @@
-import { JssmError } from './jssm_error';
-/*******
- *
- *  Predicate for validating an array for uniqueness.  Returns `true` when
- *  `el` is the first occurrence in `source`, `false` otherwise.  Intended
- *  for use as an `Array.filter` callback.  Not generally meant for external
- *  use.
- *
- *  ```typescript
- *  [1, 2, 2, 3].filter(arr_uniq_p);  // [1, 2, 3]
- *  ```
- *
- *  @param el     - The current element being tested.
- *  @param i      - The index of the current element.
- *  @param source - The full array being filtered.
- *
- *  @returns `true` if `el` is the first occurrence in `source`.
- *
- */
-function arr_uniq_p(el, i, source) {
-    return source.indexOf(el) === i;
-}
-/*******
- *
- *  Wraps a string in an array, or passes through if already non-string.
- *  Used to normalize arguments that accept either a single state name or
- *  an array of state names.
- *
- *  ```typescript
- *  array_box_if_string('hello');    // ['hello']
- *  array_box_if_string(['a','b']); // ['a','b']
- *  ```
- *
- *  @param n - A string to box, or a value to pass through unchanged.
- *
- *  @returns The input wrapped in an array if it was a string, otherwise the
- *           input unchanged.
- *
- */
-const array_box_if_string = n => typeof n === 'string' ? [n] : n;
-/*******
- *
- *  Selects a single item from a weighted array of objects using cumulative
- *  probability.  Each object in the array should have a numeric property
- *  indicating its relative weight (defaults to `'probability'`).  Objects
- *  missing the property are treated as weight 1.
- *
- *  ```typescript
- *  const opts = [
- *    { value: 'common',  probability: 0.8 },
- *    { value: 'rare',    probability: 0.2 }
- *  ];
- *
- *  weighted_rand_select(opts);  // most often { value: 'common', ... }
- *  ```
- *
- *  @param options              - Non-empty array of objects to choose from.
- *  @param probability_property - Name of the numeric weight property on each
- *                                object.  Defaults to `'probability'`.
- *  @param rng                  - Optional random number generator `() => number`
- *                                in `[0, 1)`.  Defaults to `Math.random`.
- *
- *  @returns One element from `options`, chosen by weighted random selection.
- *
- *  @throws {TypeError} If `options` is not a non-empty array of objects.
- *
- */
-// this is explicitly about other peoples' data, so it has to be weakly typed
-/* eslint-disable flowtype/no-weak-types */
-const weighted_rand_select = (options, probability_property = 'probability', rng) => {
-    if (!Array.isArray(options)) {
-        throw new TypeError('options must be a non-empty array of objects');
-    }
-    if (options.length === 0) {
-        throw new TypeError('options must be a non-empty array of objects');
-    }
-    if (!(typeof options[0] === 'object')) {
-        throw new TypeError('options must be a non-empty array of objects');
-    }
-    const frand = rng
-        ? (cap) => rng() * cap
-        : (cap) => Math.random() * cap, or_one = (item) => item === undefined ? 1 : item, prob_sum = options.reduce((acc, val) => acc + or_one(val[probability_property]), 0), rnd = frand(prob_sum);
-    let cursor = 0, cursor_sum = 0;
-    while (cursor < options.length && (cursor_sum += or_one(options[cursor++][probability_property])) <= rnd) { } // eslint-disable-line no-empty,fp/no-loops
-    return options[cursor - 1];
-};
-/* eslint-enable flowtype/no-weak-types */
-/*******
- *
- *  Returns, for a non-negative integer argument `n`, the series `[0 .. n]`.
- *
- *  ```typescript
- *  import { seq } from './jssm';
- *
- *  seq(5);  // [0, 1, 2, 3, 4]
- *  seq(0);  // []
- *  ```
- *
- */
-function seq(n) {
-    if (!(Number.isInteger(n))) {
-        throw new TypeError('seq/1 takes a non-negative integer n as an argument');
-    }
-    if (n < 0) {
-        throw new TypeError('seq/1 takes a non-negative integer n as an argument');
-    }
-    return (new Array(n))
-        .fill(true)
-        .map((_, i) => i);
-}
-/*******
- *
- *  Returns the histograph of an array as a `Map`.  Makes no attempt to cope
- *  with deep equality; will fail for complex contents, as such.
- *
- *  ```typescript
- *  import { histograph } from './jssm';
- *
- *  histograph( [0, 0, 1, 1, 2, 2, 1] );  // Map()
- *  ```
- *
- */
-const histograph = (ar) => // eslint-disable-line flowtype/no-weak-types
- [...ar].sort()
-    .reduce((m, v) => // TODO FIXME eslint-disable-line flowtype/no-weak-types,no-sequences
- (m.set(v, (m.has(v) ? m.get(v) + 1 : 1)), m), new Map());
-/*******
- *
- *  Draws `n` weighted random samples from an array of objects.  Each draw is
- *  independent (with replacement), delegating to {@link weighted_rand_select}.
- *
- *  ```typescript
- *  const opts = [
- *    { value: 'a', probability: 0.9 },
- *    { value: 'b', probability: 0.1 }
- *  ];
- *
- *  weighted_sample_select(3, opts, 'probability');
- *  // e.g. [ { value: 'a', ... }, { value: 'a', ... }, { value: 'b', ... } ]
- *  ```
- *
- *  @param n                    - Number of samples to draw.
- *  @param options              - Non-empty array of weighted objects.
- *  @param probability_property - Name of the numeric weight property.
- *  @param rng                  - Optional random number generator.
- *
- *  @returns An array of `n` independently selected items.
- *
- */
-const weighted_sample_select = (n, options, probability_property, rng) => // TODO FIXME no any // eslint-disable-line flowtype/no-weak-types
- seq(n)
-    .map((_i) => // TODO FIXME eslint-disable-line flowtype/no-weak-types
- weighted_rand_select(options, probability_property, rng));
-/*******
- *
- *  Draws `n` weighted random samples, extracts a named key from each, and
- *  returns a histograph (`Map`) of how often each key value appeared.  Useful
- *  for validating that a probabilistic transition distribution is roughly
- *  correct over many trials.
- *
- *  ```typescript
- *  const opts = [
- *    { to: 'a', probability: 0.7 },
- *    { to: 'b', probability: 0.3 }
- *  ];
- *
- *  weighted_histo_key(1000, opts, 'probability', 'to');
- *  // Map { 'a' => ~700, 'b' => ~300 }
- *  ```
- *
- *  @param n         - Number of samples to draw.
- *  @param opts      - Non-empty array of weighted objects.
- *  @param prob_prop - Name of the numeric weight property.
- *  @param extract   - Name of the property to extract from each sample for
- *                     histogramming.
- *  @param rng       - Optional random number generator.
- *
- *  @returns A `Map` from extracted key values to their occurrence counts.
- *
- */
-const weighted_histo_key = (n, opts, prob_prop, extract, rng) => // TODO FIXME no any // eslint-disable-line flowtype/no-weak-types
- histograph(weighted_sample_select(n, opts, prob_prop, rng)
-    .map((s) => s[extract] // TODO FIXME eslint-disable-line flowtype/no-weak-types
-));
-/*******
- *
- *  Internal method generating composite keys for the hook lookup map by
- *  JSON-serializing a `[property, state]` pair.  Not meant for external use.
- *
- *  ```typescript
- *  name_bind_prop_and_state('color', 'Red');  // '["color","Red"]'
- *  ```
- *
- *  @param prop  - The property name (e.g. a data key or hook category).
- *  @param state - The state name to bind to.
- *
- *  @returns A deterministic JSON string key for the `[prop, state]` pair.
- *
- *  @throws {JssmError} If either argument is not a string.
- *
- */
-function name_bind_prop_and_state(prop, state) {
-    if (typeof prop !== 'string') {
-        throw new JssmError(undefined, `Name of property must be a string; got ${prop}`);
-    }
-    if (typeof state !== 'string') {
-        throw new JssmError(undefined, `Name of state must be a string; got ${state}`);
-    }
-    return JSON.stringify([prop, state]);
-}
-/*******
- *
- *  Internal method generating composite keys for transition hooks by
- *  JSON-serializing a `[from, to]` state pair.  Used to look up hooks
- *  registered on a specific edge.  Not meant for external use.
- *
- *  ```typescript
- *  hook_name('Red', 'Green');  // '["Red","Green"]'
- *  ```
- *
- *  @param from - The source state name.
- *  @param to   - The target state name.
- *
- *  @returns A deterministic JSON string key for the `[from, to]` pair.
- *
- */
-const hook_name = (from, to) => JSON.stringify([from, to]);
-/*******
- *
- *  Internal method generating composite keys for named-action hooks by
- *  JSON-serializing a `[from, to, action]` triple.  Used to look up hooks
- *  registered on a specific action-labeled edge.  Not meant for external use.
- *
- *  ```typescript
- *  named_hook_name('Red', 'Green', 'next');  // '["Red","Green","next"]'
- *  ```
- *
- *  @param from   - The source state name.
- *  @param to     - The target state name.
- *  @param action - The action label on the edge.
- *
- *  @returns A deterministic JSON string key for the `[from, to, action]` triple.
- *
- */
-const named_hook_name = (from, to, action) => JSON.stringify([from, to, action]);
-/*******
- *
- *  Creates a SplitMix32 random generator.  Used by the randomness test suite.
- *
- *  Sourced from `bryc`: https://github.com/bryc/code/blob/master/jshash/PRNGs.md#splitmix32
- *
- *  Replaces the Mulberry generator, which was found to have problems
- *
- */
-function gen_splitmix32(a) {
-    if (a === undefined) {
-        a = new Date().getTime();
-    }
-    return function () {
-        a |= 0;
-        a = a + 0x9e3779b9 | 0;
-        let t = a ^ a >>> 16;
-        t = Math.imul(t, 0x21f0aaad);
-        t = t ^ t >>> 15;
-        t = Math.imul(t, 0x735a2d97);
-        return ((t = t ^ t >>> 15) >>> 0) / 4294967296;
-    };
-}
-/*******
- *
- *  Reduces an array to its unique contents.  Compares with `===` and makes no
- *  effort to deep-compare contents; two matching arrays or objects contained
- *  will be treated as distinct, according to javascript rules.  This also means
- *  that `NaNs` will be ***dropped***, because they do not self-compare.
- *
- *  ```typescript
- *  unique( [] );                     // []
- *  unique( [0,0] );                  // [0]
- *  unique( [0,1,2, 0,1,2, 0,1,2] );  // [0,1,2]
- *  unique( [ [1], [1] ] );           // [ [1], [1] ] because arrays don't match
- *  unique( [0,NaN,2] );              // [0,2]
- *  ```
- *
- */
-const unique = (arr) => arr.filter((v, i, a) => a.indexOf(v) === i);
-/*******
- *
- *  Lists all repeated items in an array along with their counts.  Subject to
- *  matching rules of Map.  `NaN` is manually removed because of conflict rules
- *  around {@link unique}.  Because these are compared with `===` and because
- *  arrays and objects never match that way unless they're the same object,
- *  arrays and objects are never considered repeats.
- *
- *  ```typescript
- *  find_repeated<string>([ ]);                     // []
- *  find_repeated<string>([ "one" ]);               // []
- *  find_repeated<string>([ "one", "two" ]);        // []
- *  find_repeated<string>([ "one", "one" ]);        // [ ["one", 2] ]
- *  find_repeated<string>([ "one", "two", "one" ]); // [ ["one", 2] ]
- *  find_repeated<number>([ 0, NaN, 0, NaN ]);      // [ [0,     2] ]
- *  ```
- *
- */
-function find_repeated(arr) {
-    const uniqued = unique(arr);
-    if (uniqued.length !== arr.length) {
-        const residue_keys = new Map();
-        arr.forEach(k => residue_keys.set(k, residue_keys.has(k)
-            ? (residue_keys.get(k) + 1)
-            : 1));
-        uniqued.forEach(k => residue_keys.set(k, residue_keys.get(k) - 1));
-        return [...residue_keys.entries()]
-            .filter((e) => ((e[1] > 0) && (!(Number.isNaN(e[0])))))
-            .map((e) => [e[0], e[1] + 1]);
-    }
-    else {
-        return [];
-    }
-}
-/*******
- *
- *  Returns a `Promise` that resolves after `ms` milliseconds.  Useful for
- *  inserting delays in async test flows or demos.
- *
- *  ```typescript
- *  await sleep(100);  // pauses execution for 100ms
- *  ```
- *
- *  @param ms - Number of milliseconds to wait before resolving.
- *
- *  @returns A `Promise<void>` that resolves after the timeout.
- *
- */
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-export { seq, unique, find_repeated, arr_uniq_p, histograph, weighted_histo_key, weighted_rand_select, weighted_sample_select, array_box_if_string, name_bind_prop_and_state, hook_name, named_hook_name, gen_splitmix32, sleep };