jssm 5.35.4 → 5.42.0

package/src/ts/tests/stop light.spec.ts

@@ -1,157 +1,157 @@
-
-/* eslint-disable max-len */
-
-import * as jssm from '../jssm';
-
-
-
-
-
-describe('Simple stop light', () => {
-
-  const light = jssm.sm`Red 'Proceed' -> Green 'Proceed' -> Yellow 'Proceed' -> Red;`;
-
-  const r_states = light.states();
-
-  test('has the right state count', () =>
-    expect(r_states.length).toBe(3));
-
-  ['Red', 'Yellow', 'Green'].map(c =>
-    test(`has state "${c}"`, () =>
-      expect(r_states.includes(c)).toBe(true))
-  );
-
-  describe('- `proceed` walkthrough', () => {
-
-    test('machine starts red',  () => expect( light.state()           ).toBe( "Red"    ));
-    test('proceed is true',     () => expect( light.action('Proceed') ).toBe( true     ));
-    test('light is now green',  () => expect( light.state()           ).toBe( "Green"  ));
-    test('proceed is true 2',   () => expect( light.action('Proceed') ).toBe( true     ));
-    test('light is now yellow', () => expect( light.state()           ).toBe( "Yellow" ));
-    test('proceed is true 3',   () => expect( light.action('Proceed') ).toBe( true     ));
-    test('light is red again',  () => expect( light.state()           ).toBe( "Red"    ));
-
-  });
-
-  describe('- mixed - `proceed` and `transition`', () => {
-
-    test('machine starts red',              () => expect( light.state()              ).toBe("Red")    );
-    test('proceed is true',                 () => expect( light.action('Proceed')    ).toBe( true )   );
-    test('machine is now green',            () => expect( light.state()              ).toBe("Green")  );
-
-    test('refuses transition red',          () => expect( light.transition('Red')    ).toBe( false )  );
-    test('green still green',               () => expect( light.state()              ).toBe("Green")  );
-    test('refuses transition green',        () => expect( light.transition('Green')  ).toBe( false )  );
-    test('green still green',               () => expect( light.state()              ).toBe("Green")  );
-    test('accepts transition yellow',       () => expect( light.transition('Yellow') ).toBe( true )   );
-    test('green now yellow',                () => expect( light.state()              ).toBe("Yellow") );
-
-    test('proceed is true',                 () => expect( light.action('Proceed')    ).toBe( true )   );
-    test('machine is now red',              () => expect( light.state()              ).toBe("Red")    );
-
-    test('refuses transition yellow',       () => expect( light.transition('Yellow') ).toBe( false )  );
-    test('green still green',               () => expect( light.state()              ).toBe("Red")    );
-    test('refuses transition red',          () => expect( light.transition('Red')    ).toBe( false )  );
-    test('green still green',               () => expect( light.state()              ).toBe("Red")    );
-    test('accepts transition green',        () => expect( light.transition('Green')  ).toBe( true )   );
-    test('red now green',                   () => expect( light.state()              ).toBe("Green")  );
-
-    test('proceed is true',                 () => expect( light.action('Proceed')    ).toBe( true )   );
-    test('machine is now yellow',           () => expect( light.state()              ).toBe("Yellow") );
-    test('proceed is true',                 () => expect( light.action('Proceed')    ).toBe( true )   );
-    test('machine is now red',              () => expect( light.state()              ).toBe("Red")    );
-
-  });
-
-});
-
-
-
-
-
-
-
-describe('Complex stop light', () => {
-
-  const light2 = new jssm.Machine({
-
-    start_states: ['off'],
-
-    transitions:[
-
-      { name:'turn_on',     kind: 'legal', forced_only: false, main_path: false, action:'power_on',  from:'off',    to:'red'},
-
-      {                     kind: 'legal', forced_only: false, main_path: false, action:'power_off', from:'red',    to:'off' },
-      {                     kind: 'legal', forced_only: false, main_path: false, action:'power_off', from:'yellow', to:'off' },
-      {                     kind: 'legal', forced_only: false, main_path: false, action:'power_off', from:'green',  to:'off' },
-
-      { name:'switch_warn', kind: 'legal', forced_only: false, main_path: false, action:'proceed',   from:'green',  to:'yellow' },
-      { name:'switch_halt', kind: 'legal', forced_only: false, main_path: false, action:'proceed',   from:'yellow', to:'red'    },
-      { name:'switch_go',   kind: 'legal', forced_only: false, main_path: false, action:'proceed',   from:'red',    to:'green'  }
-
-    ]
-
-  });
-
-  const r_states = light2.states();
-
-  test('has the right state count', () =>
-    expect(r_states.length).toBe(4));
-
-  ['red', 'yellow', 'green', 'off'].map(c =>
-    test(`has state "${c}"`, () =>
-      expect(r_states.includes(c)).toBe(true))
-  );
-
-  const r_names = light2.list_named_transitions();
-
-  test('has the right named transition count', () =>
-    expect(r_names.size).toBe(4));
-
-  ['turn_on', 'switch_warn', 'switch_halt', 'switch_go'].map(a =>
-    test(`has named transition "${a}"`, () =>
-      expect(r_names.has(a)).toBe(true))
-  );
-
-  test('has the right exit actions for red', () =>
-    expect(['power_off', 'proceed']).toEqual(light2.list_exit_actions('red')) );
-
-
-  describe('- `transition` walkthrough', () => {
-
-    test('machine starts off',    () => expect( light2.state()              ).toBe("off")    );
-    test('off refuses green',     () => expect( light2.transition('green')  ).toBe(false)    );
-    test('off refuses yellow',    () => expect( light2.transition('yellow') ).toBe(false)    );
-
-    test('off refuses proceed',   () => expect( light2.action('proceed')    ).toBe(false)    );
-
-    test('off accepts red',       () => expect( light2.transition('red')    ).toBe(true)     );
-    test('off is now red',        () => expect( light2.state()              ).toBe("red")    );
-    test('red refuses yellow',    () => expect( light2.transition('yellow') ).toBe(false)    );
-    test('red still red',         () => expect( light2.state()              ).toBe("red")    );
-    test('red refuses red',       () => expect( light2.transition('red')    ).toBe(false)    );
-    test('red still red 2',       () => expect( light2.state()              ).toBe("red")    );
-
-    test('red accepts green',     () => expect( light2.transition('green')  ).toBe(true)     );
-    test('red now green',         () => expect( light2.state()              ).toBe("green")  );
-    test('green refuses red',     () => expect( light2.transition('red')    ).toBe(false)    );
-    test('green still green',     () => expect( light2.state()              ).toBe("green")  );
-    test('green refuses green',   () => expect( light2.transition('green')  ).toBe(false)    );
-    test('green still green 2',   () => expect( light2.state()              ).toBe("green")  );
-
-    test('green accepts yellow',  () => expect( light2.transition('yellow') ).toBe(true)     );
-    test('green now yellow',      () => expect( light2.state()              ).toBe("yellow") );
-    test('yellow refuses green',  () => expect( light2.transition('green')  ).toBe(false)    );
-    test('yellow still yellow',   () => expect( light2.state()              ).toBe("yellow") );
-    test('yellow refuses yellow', () => expect( light2.transition('yellow') ).toBe(false)    );
-    test('yellow still yellow 2', () => expect( light2.state()              ).toBe("yellow") );
-
-    test('yellow accepts red',    () => expect( light2.transition('red')    ).toBe(true)     );
-    test('back to red',           () => expect( light2.state()              ).toBe("red")    );
-
-    test('proceed is true',       () => expect( light2.action('proceed')    ).toBe(true)     );
-    test('light is now green',    () => expect( light2.state()              ).toBe("green")  );
-
-  });
-
-});
+
+/* eslint-disable max-len */
+
+import * as jssm from '../jssm';
+
+
+
+
+
+describe('Simple stop light', () => {
+
+  const light = jssm.sm`Red 'Proceed' -> Green 'Proceed' -> Yellow 'Proceed' -> Red;`;
+
+  const r_states = light.states();
+
+  test('has the right state count', () =>
+    expect(r_states.length).toBe(3));
+
+  ['Red', 'Yellow', 'Green'].map(c =>
+    test(`has state "${c}"`, () =>
+      expect(r_states.includes(c)).toBe(true))
+  );
+
+  describe('- `proceed` walkthrough', () => {
+
+    test('machine starts red',  () => expect( light.state()           ).toBe( "Red"    ));
+    test('proceed is true',     () => expect( light.action('Proceed') ).toBe( true     ));
+    test('light is now green',  () => expect( light.state()           ).toBe( "Green"  ));
+    test('proceed is true 2',   () => expect( light.action('Proceed') ).toBe( true     ));
+    test('light is now yellow', () => expect( light.state()           ).toBe( "Yellow" ));
+    test('proceed is true 3',   () => expect( light.action('Proceed') ).toBe( true     ));
+    test('light is red again',  () => expect( light.state()           ).toBe( "Red"    ));
+
+  });
+
+  describe('- mixed - `proceed` and `transition`', () => {
+
+    test('machine starts red',              () => expect( light.state()              ).toBe("Red")    );
+    test('proceed is true',                 () => expect( light.action('Proceed')    ).toBe( true )   );
+    test('machine is now green',            () => expect( light.state()              ).toBe("Green")  );
+
+    test('refuses transition red',          () => expect( light.transition('Red')    ).toBe( false )  );
+    test('green still green',               () => expect( light.state()              ).toBe("Green")  );
+    test('refuses transition green',        () => expect( light.transition('Green')  ).toBe( false )  );
+    test('green still green',               () => expect( light.state()              ).toBe("Green")  );
+    test('accepts transition yellow',       () => expect( light.transition('Yellow') ).toBe( true )   );
+    test('green now yellow',                () => expect( light.state()              ).toBe("Yellow") );
+
+    test('proceed is true',                 () => expect( light.action('Proceed')    ).toBe( true )   );
+    test('machine is now red',              () => expect( light.state()              ).toBe("Red")    );
+
+    test('refuses transition yellow',       () => expect( light.transition('Yellow') ).toBe( false )  );
+    test('green still green',               () => expect( light.state()              ).toBe("Red")    );
+    test('refuses transition red',          () => expect( light.transition('Red')    ).toBe( false )  );
+    test('green still green',               () => expect( light.state()              ).toBe("Red")    );
+    test('accepts transition green',        () => expect( light.transition('Green')  ).toBe( true )   );
+    test('red now green',                   () => expect( light.state()              ).toBe("Green")  );
+
+    test('proceed is true',                 () => expect( light.action('Proceed')    ).toBe( true )   );
+    test('machine is now yellow',           () => expect( light.state()              ).toBe("Yellow") );
+    test('proceed is true',                 () => expect( light.action('Proceed')    ).toBe( true )   );
+    test('machine is now red',              () => expect( light.state()              ).toBe("Red")    );
+
+  });
+
+});
+
+
+
+
+
+
+
+describe('Complex stop light', () => {
+
+  const light2 = new jssm.Machine({
+
+    start_states: ['off'],
+
+    transitions:[
+
+      { name:'turn_on',     kind: 'legal', forced_only: false, main_path: false, action:'power_on',  from:'off',    to:'red'},
+
+      {                     kind: 'legal', forced_only: false, main_path: false, action:'power_off', from:'red',    to:'off' },
+      {                     kind: 'legal', forced_only: false, main_path: false, action:'power_off', from:'yellow', to:'off' },
+      {                     kind: 'legal', forced_only: false, main_path: false, action:'power_off', from:'green',  to:'off' },
+
+      { name:'switch_warn', kind: 'legal', forced_only: false, main_path: false, action:'proceed',   from:'green',  to:'yellow' },
+      { name:'switch_halt', kind: 'legal', forced_only: false, main_path: false, action:'proceed',   from:'yellow', to:'red'    },
+      { name:'switch_go',   kind: 'legal', forced_only: false, main_path: false, action:'proceed',   from:'red',    to:'green'  }
+
+    ]
+
+  });
+
+  const r_states = light2.states();
+
+  test('has the right state count', () =>
+    expect(r_states.length).toBe(4));
+
+  ['red', 'yellow', 'green', 'off'].map(c =>
+    test(`has state "${c}"`, () =>
+      expect(r_states.includes(c)).toBe(true))
+  );
+
+  const r_names = light2.list_named_transitions();
+
+  test('has the right named transition count', () =>
+    expect(r_names.size).toBe(4));
+
+  ['turn_on', 'switch_warn', 'switch_halt', 'switch_go'].map(a =>
+    test(`has named transition "${a}"`, () =>
+      expect(r_names.has(a)).toBe(true))
+  );
+
+  test('has the right exit actions for red', () =>
+    expect(['power_off', 'proceed']).toEqual(light2.list_exit_actions('red')) );
+
+
+  describe('- `transition` walkthrough', () => {
+
+    test('machine starts off',    () => expect( light2.state()              ).toBe("off")    );
+    test('off refuses green',     () => expect( light2.transition('green')  ).toBe(false)    );
+    test('off refuses yellow',    () => expect( light2.transition('yellow') ).toBe(false)    );
+
+    test('off refuses proceed',   () => expect( light2.action('proceed')    ).toBe(false)    );
+
+    test('off accepts red',       () => expect( light2.transition('red')    ).toBe(true)     );
+    test('off is now red',        () => expect( light2.state()              ).toBe("red")    );
+    test('red refuses yellow',    () => expect( light2.transition('yellow') ).toBe(false)    );
+    test('red still red',         () => expect( light2.state()              ).toBe("red")    );
+    test('red refuses red',       () => expect( light2.transition('red')    ).toBe(false)    );
+    test('red still red 2',       () => expect( light2.state()              ).toBe("red")    );
+
+    test('red accepts green',     () => expect( light2.transition('green')  ).toBe(true)     );
+    test('red now green',         () => expect( light2.state()              ).toBe("green")  );
+    test('green refuses red',     () => expect( light2.transition('red')    ).toBe(false)    );
+    test('green still green',     () => expect( light2.state()              ).toBe("green")  );
+    test('green refuses green',   () => expect( light2.transition('green')  ).toBe(false)    );
+    test('green still green 2',   () => expect( light2.state()              ).toBe("green")  );
+
+    test('green accepts yellow',  () => expect( light2.transition('yellow') ).toBe(true)     );
+    test('green now yellow',      () => expect( light2.state()              ).toBe("yellow") );
+    test('yellow refuses green',  () => expect( light2.transition('green')  ).toBe(false)    );
+    test('yellow still yellow',   () => expect( light2.state()              ).toBe("yellow") );
+    test('yellow refuses yellow', () => expect( light2.transition('yellow') ).toBe(false)    );
+    test('yellow still yellow 2', () => expect( light2.state()              ).toBe("yellow") );
+
+    test('yellow accepts red',    () => expect( light2.transition('red')    ).toBe(true)     );
+    test('back to red',           () => expect( light2.state()              ).toBe("red")    );
+
+    test('proceed is true',       () => expect( light2.action('proceed')    ).toBe(true)     );
+    test('light is now green',    () => expect( light2.state()              ).toBe("green")  );
+
+  });
+
+});

package/src/ts/tests/stripes.spec.ts

@@ -1,52 +1,52 @@
-
-/* eslint-disable max-len */
-
-import * as jssm from '../jssm';
-
-
-
-
-
-describe('stripe strategies', () => {
-
-
-
-  const is_v = (str, v) =>
-    test(str, () =>
-      expect( jssm.parse(str) ).toEqual(v)
-    );
-
-
-
-  describe('basic stripe', () => {
-    is_v(
-      '[a b c] -> +|1;',
-      [{from: ['a','b','c'], key: 'transition', se: {kind: '->', to: {key: 'stripe', value: 1}}}]
-    );
-  });
-
-  describe('negative stripe', () => {
-    is_v(
-      '[a b c] -> -|1;',
-      [{from: ['a','b','c'], key: 'transition', se: {kind: '->', to: {key: 'stripe', value: -1}}}]
-    );
-  });
-
-  describe('wide stripe', () => {
-    is_v(
-      '[a b c] -> +|2;',
-      [{from: ['a','b','c'], key: 'transition', se: {kind: '->', to: {key: 'stripe', value: 2}}}]
-    );
-  });
-
-
-
-  test('illegal fractional stripe throws', () => {
-
-    expect( () =>
-      jssm.parse('[a b c] -> +|2.5;')
-    ).toThrow();
-
-  });
-
-});
+
+/* eslint-disable max-len */
+
+import * as jssm from '../jssm';
+
+
+
+
+
+describe('stripe strategies', () => {
+
+
+
+  const is_v = (str, v) =>
+    test(str, () =>
+      expect( jssm.parse(str) ).toEqual(v)
+    );
+
+
+
+  describe('basic stripe', () => {
+    is_v(
+      '[a b c] -> +|1;',
+      [{from: ['a','b','c'], key: 'transition', se: {kind: '->', to: {key: 'stripe', value: 1}}}]
+    );
+  });
+
+  describe('negative stripe', () => {
+    is_v(
+      '[a b c] -> -|1;',
+      [{from: ['a','b','c'], key: 'transition', se: {kind: '->', to: {key: 'stripe', value: -1}}}]
+    );
+  });
+
+  describe('wide stripe', () => {
+    is_v(
+      '[a b c] -> +|2;',
+      [{from: ['a','b','c'], key: 'transition', se: {kind: '->', to: {key: 'stripe', value: 2}}}]
+    );
+  });
+
+
+
+  test('illegal fractional stripe throws', () => {
+
+    expect( () =>
+      jssm.parse('[a b c] -> +|2.5;')
+    ).toThrow();
+
+  });
+
+});

package/src/ts/tests/theme.spec.ts

@@ -1,45 +1,45 @@
-
-import { Themes } from './constants.spec';
-
-import { sm } from '../jssm';
-
-
-
-
-
-const baseline       = sm`theme: ocean; z -> q;`,
-      baseline_theme = baseline.theme();
-
-test('Themes sound like the ocean', () =>
-  expect(baseline_theme).toBe('ocean') );
-
-
-
-const no_baseline       = sm`z -> q;`,
-      no_baseline_theme = no_baseline.theme();
-
-test('No theme sounds like none', () =>
-  expect(no_baseline_theme).toBe('default') );
-
-
-
-
-
-describe('Named themes', () => {
-
-  Themes.map(thisTheme =>
-    test(`Theme "${thisTheme}" parses as a theme`, () =>
-      expect( () => { const _foo = sm`theme: ${thisTheme}; a-> b;`; }).not.toThrow() ) );
-
-  Themes.map(thisTheme =>
-    test(`Theme "${thisTheme}" shows correct theme`, () =>
-      expect( sm`theme: ${thisTheme}; a-> b;`.theme() ).toBe(thisTheme) ) );
-
-  Themes.map(thisTheme =>
-    test(`Missing theme shows theme "default"`, () =>
-      expect( sm`a-> b;`.theme() ).toBe("default") ) );
-
-  test('Fake theme throws', () =>
-    expect( () => { const _foo = sm`theme: zeghezgqqqqthirteen; a-> b;`; }).toThrow() );
-
-});
+
+import { Themes } from './constants.spec';
+
+import { sm } from '../jssm';
+
+
+
+
+
+const baseline       = sm`theme: ocean; z -> q;`,
+      baseline_theme = baseline.theme();
+
+test('Themes sound like the ocean', () =>
+  expect(baseline_theme).toBe('ocean') );
+
+
+
+const no_baseline       = sm`z -> q;`,
+      no_baseline_theme = no_baseline.theme();
+
+test('No theme sounds like none', () =>
+  expect(no_baseline_theme).toBe('default') );
+
+
+
+
+
+describe('Named themes', () => {
+
+  Themes.map(thisTheme =>
+    test(`Theme "${thisTheme}" parses as a theme`, () =>
+      expect( () => { const _foo = sm`theme: ${thisTheme}; a-> b;`; }).not.toThrow() ) );
+
+  Themes.map(thisTheme =>
+    test(`Theme "${thisTheme}" shows correct theme`, () =>
+      expect( sm`theme: ${thisTheme}; a-> b;`.theme() ).toBe(thisTheme) ) );
+
+  Themes.map(thisTheme =>
+    test(`Missing theme shows theme "default"`, () =>
+      expect( sm`a-> b;`.theme() ).toBe("default") ) );
+
+  test('Fake theme throws', () =>
+    expect( () => { const _foo = sm`theme: zeghezgqqqqthirteen; a-> b;`; }).toThrow() );
+
+});

package/src/ts/tests/weighted_histo_key.spec.ts

@@ -1,22 +1,22 @@
-
-import * as jssm from '../jssm';
-
-
-
-
-
-describe('weighted_histo_key/2', () => {
-
-  const fruit = [ { label: 'apple',  probability: 0.1 },
-                  { label: 'orange', probability: 0.4 },
-                  { label: 'banana', probability: 0.5 } ];
-
-  const out = jssm.weighted_histo_key(10000, fruit, 'probability', 'label');
-
-  test('produces a well formed probability map', () =>
-    expect([... out.keys()].length).toBe(3)
-  );
-
-});
-
-// stochable
+
+import * as jssm from '../jssm';
+
+
+
+
+
+describe('weighted_histo_key/2', () => {
+
+  const fruit = [ { label: 'apple',  probability: 0.1 },
+                  { label: 'orange', probability: 0.4 },
+                  { label: 'banana', probability: 0.5 } ];
+
+  const out = jssm.weighted_histo_key(10000, fruit, 'probability', 'label');
+
+  test('produces a well formed probability map', () =>
+    expect([... out.keys()].length).toBe(3)
+  );
+
+});
+
+// stochable

package/src/ts/tests/weighted_rand_select.spec.ts

@@ -1,27 +1,27 @@
-
-import * as jssm from '../jssm';
-
-
-
-
-
-describe('weighted_rand_select/2', () => {
-
-  const fruit = [ { label: 'apple',  probability: 0.1 },
-                  { label: 'orange', probability: 0.4 },
-                  { label: 'banana', probability: 0.5 } ];
-
-  const acc = { apple: 0, orange: 0, banana: 0 };
-
-  for (let i=0; i<10000; ++i) {
-    acc[jssm.weighted_rand_select(fruit).label] = acc[jssm.weighted_rand_select(fruit).label] + 1;
-  }
-
-  test('banana baseline',                () => expect( acc.banana > 3000 ).toBe(true) );
-
-  test('requires an array',              () => expect( () => jssm.weighted_rand_select( 'not_an_array' )).toThrow() );
-  test('requires members to be objects', () => expect( () => jssm.weighted_rand_select( ['not_an_obj'] )).toThrow() );
-
-});
-
-// stochable
+
+import * as jssm from '../jssm';
+
+
+
+
+
+describe('weighted_rand_select/2', () => {
+
+  const fruit = [ { label: 'apple',  probability: 0.1 },
+                  { label: 'orange', probability: 0.4 },
+                  { label: 'banana', probability: 0.5 } ];
+
+  const acc = { apple: 0, orange: 0, banana: 0 };
+
+  for (let i=0; i<10000; ++i) {
+    acc[jssm.weighted_rand_select(fruit).label] = acc[jssm.weighted_rand_select(fruit).label] + 1;
+  }
+
+  test('banana baseline',                () => expect( acc.banana > 3000 ).toBe(true) );
+
+  test('requires an array',              () => expect( () => jssm.weighted_rand_select( 'not_an_array' )).toThrow() );
+  test('requires members to be objects', () => expect( () => jssm.weighted_rand_select( ['not_an_obj'] )).toThrow() );
+
+});
+
+// stochable