The machine data type — the type of the value stored in
.data(). Defaults to undefined when no data is used.
Get the style for the active state. Does not include composition from an applied theme, or things from the underlying base stylesheet; only the modifications applied by this machine.
const light = sm`a -> b;`;
console.log(light.active_state_style);
// {}
const light = sm`a -> b; active_state: { shape: circle; };`;
console.log(light.active_state_style);
// { shape: 'circle' }
The JssmStateConfig for the active state.
Check if a machine allows overriding state and data. Resolves the combined effect of code and config permissions — config may not be less strict than code.
The effective override permission.
Check if the code that built the machine allows overriding state and data.
The override permission from the FSL source code.
Check if the machine config allows overriding state and data.
The override permission from the runtime config.
Get the timestamp when construction began (before parsing).
The start-of-construction timestamp as a number.
Get the creation date of this machine as a Date object.
A Date representing when the machine was created.
Get the creation timestamp (milliseconds since epoch).
The timestamp as a number.
Get the end state style. Does not include composition from an applied theme, or things from the underlying base stylesheet; only the modifications applied by this machine.
End states are defined in the directive end_states, and are distinct
from terminal states. End states are voluntary successful endpoints for a
process. Terminal states are states that cannot be exited. By example,
most error states are terminal states, but not end states. Also, since
some end states can be exited and are determined by hooks, such as
recursive or iterative nodes, there is such a thing as an end state that
is not a terminal state.
const light = sm`a -> b;`;
console.log(light.standard_state_style);
// {}
const light = sm`a -> b; end_state: { shape: circle; };`;
console.log(light.standard_state_style);
// { shape: 'circle' }
The JssmStateConfig for end states.
Get a truncated history of the recent states and data of the machine.
Turned off by default; configure with .from('...', {data: 5}) by length,
or set .history_length at runtime.
History does not contain the current state. If you want that, call
.history_inclusive instead.
const foo = jssm.from(
"a 'next' -> b 'next' -> c 'next' -> d 'next' -> e;",
{ history: 3 }
);
foo.action('next');
foo.action('next');
foo.action('next');
foo.action('next');
foo.history; // [ ['b',undefined], ['c',undefined], ['d',undefined] ]
Notice that the machine's current state, e, is not in the returned list.
Get a truncated history of the recent states and data of the machine,
including the current state. Turned off by default; configure with
.from('...', {data: 5}) by length, or set .history_length at runtime.
History inclusive contains the current state. If you only want past
states, call .history instead.
The list returned will be one longer than the history buffer kept, as the history buffer kept gets the current state added to it to produce this list.
const foo = jssm.from(
"a 'next' -> b 'next' -> c 'next' -> d 'next' -> e;",
{ history: 3 }
);
foo.action('next');
foo.action('next');
foo.action('next');
foo.action('next');
foo.history_inclusive; // [ ['b',undefined], ['c',undefined], ['d',undefined], ['e',undefined] ]
Notice that the machine's current state, e, is in the returned list.
Find out how long a history this machine is keeping. Defaults to zero. Settable directly.
const foo = jssm.from("a -> b;");
foo.history_length; // 0
const bar = jssm.from("a -> b;", { history: 3 });
foo.history_length; // 3
foo.history_length = 5;
foo.history_length; // 5
Find out how long a history this machine is keeping. Defaults to zero. Settable directly.
const foo = jssm.from("a -> b;");
foo.history_length; // 0
const bar = jssm.from("a -> b;", { history: 3 });
foo.history_length; // 3
foo.history_length = 5;
foo.history_length; // 5
Get the hooked state style. Does not include composition from an applied theme, or things from the underlying base stylesheet; only the modifications applied by this machine.
The hooked style is only applied to nodes which have a named hook in the graph. Open hooks set through the external API aren't graphed, because that would be literally every node.
const light = sm`a -> b;`;
console.log(light.hooked_state_style);
// {}
const light = sm`a -> b; hooked_state: { shape: circle; };`;
console.log(light.hooked_state_style);
// { shape: 'circle' }
The JssmStateConfig for hooked states.
Get the current RNG seed used for probabilistic transitions.
The numeric seed value.
Set the RNG seed. Pass undefined to reseed from the current time.
Resets the internal PRNG so subsequent probabilistic operations use the
new seed.
The seed value, or undefined for time-based seeding.
The numeric seed value.
Get the standard style for a single state. Does not include composition from an applied theme, or things from the underlying base stylesheet; only the modifications applied by this machine.
const light = sm`a -> b;`;
console.log(light.standard_state_style);
// {}
const light = sm`a -> b; state: { shape: circle; };`;
console.log(light.standard_state_style);
// { shape: 'circle' }
The JssmStateConfig for standard states.
Get the start state style. Does not include composition from an applied theme, or things from the underlying base stylesheet; only the modifications applied by this machine.
Start states are defined by the directive start_states, or in absentia,
are the first mentioned state.
const light = sm`a -> b;`;
console.log(light.start_state_style);
// {}
const light = sm`a -> b; start_state: { shape: circle; };`;
console.log(light.start_state_style);
// { shape: 'circle' }
The JssmStateConfig for start states.
Get the terminal state style. Does not include composition from an applied theme, or things from the underlying base stylesheet; only the modifications applied by this machine.
Terminal state styles are automatically determined by the machine. Any state without a valid exit transition is terminal.
const light = sm`a -> b;`;
console.log(light.terminal_state_style);
// {}
const light = sm`a -> b; terminal_state: { shape: circle; };`;
console.log(light.terminal_state_style);
// { shape: 'circle' }
The JssmStateConfig for terminal states.
Get the active theme(s) for this machine. Always stored as an array internally; the union return type exists for setter compatibility.
The current theme or array of themes.
Set the active theme(s). Accepts a single theme name or an array.
A theme name or array of theme names to apply.
The current theme or array of themes.
Whether any actions are defined on this machine.
true if the machine has at least one action.
Whether any forced (~>) transitions exist in this machine.
true if at least one forced transition is defined.
Internal method for fabricating states. Not meant for external use.
Instruct the machine to complete an action. Synonym for do.
const light = sm`red 'next' -> green 'next' -> yellow 'next' -> red; [red yellow green] 'shutdown' ~> off 'start' -> red;`;
light.state(); // 'red'
light.action('next'); // true
light.state(); // 'green'
The action to engage
The data change to insert during the action
true if the action was valid and the transition occurred,
false otherwise.
List all actions available from this state. Please note that the order of the actions is not guaranteed.
import { sm } from 'jssm';
const machine = sm`
red 'next' -> green 'next' -> yellow 'next' -> red;
[red yellow green] 'shutdown' ~> off 'start' -> red;
`;
console.log( machine.state() ); // logs 'red'
console.log( machine.actions() ); // logs ['next', 'shutdown']
machine.action('next'); // true
console.log( machine.state() ); // logs 'green'
console.log( machine.actions() ); // logs ['next', 'shutdown']
machine.action('shutdown'); // true
console.log( machine.state() ); // logs 'off'
console.log( machine.actions() ); // logs ['start']
machine.action('start'); // true
console.log( machine.state() ); // logs 'red'
console.log( machine.actions() ); // logs ['next', 'shutdown']
The state whose actions to list. Defaults to the current state.
An array of action names available from the given state.
List all available theme names.
An array of theme name strings.
If the current state has an after timeout configured, schedule it.
Called internally after each transition.
Cancel any pending state timeout. Safe to call when no timeout is active.
Get the full transition object for an action from the current state.
The action name.
The JssmTransition object.
Get the edge index for an action from the current state.
The action name.
The edge index, or undefined if the action is not available.
Get the configured after timeout for the current state, if any.
A [targetState, delayMs] tuple, or undefined.
Get the current data of a machine.
import * as jssm from 'jssm';
const lswitch = jssm.from('on <=> off;', {data: 1});
console.log( lswitch.data() ); // 1
A deep clone of the machine's current data value.
Get whatever the node should show as text.
Currently, this means to get the label for a given state, if any; otherwise to return the node's name. However, this definition is expected to grow with time, and it is currently considered ill-advised to manually parse this text.
See also label_for.
import * as jssm from 'jssm';
const lswitch = jssm.from('a -> b; state a: { label: "Foo!"; };');
console.log( lswitch.display_text('a') ); // 'Foo!'
console.log( lswitch.display_text('b') ); // 'b'
The state to get display text for.
The label if one exists, otherwise the state's name.
Instruct the machine to complete an action. Synonym for action.
const light = sm`
off 'start' -> red;
red 'next' -> green 'next' -> yellow 'next' -> red;
[red yellow green] 'shutdown' ~> off;
`;
light.state(); // 'off'
light.do('start'); // true
light.state(); // 'red'
light.do('next'); // true
light.state(); // 'green'
light.do('next'); // true
light.state(); // 'yellow'
light.do('dance'); // !! false - no such action
light.state(); // 'yellow'
light.do('start'); // !! false - yellow does not have the action start
light.state(); // 'yellow'
The action to engage
The data change to insert during the action
true if the action was valid and the transition occurred,
false otherwise.
Get the Graphviz DOT preamble string, injected before the graph body
during visualization. Set via the FSL dot_preamble directive.
The preamble string.
Get all edges between two states (there can be multiple with different actions).
Source state name.
Target state name.
An array of matching JssmTransition objects.
Get the flow direction for graph layout (e.g. 'right', 'down').
Set via the FSL flow directive.
The current flow direction.
Instruct the machine to complete a forced transition (which will reject if called with a normal transition call.)
const light = sm`red -> green -> yellow -> red; [red yellow green] 'shutdown' ~> off 'start' -> red;`;
light.state(); // 'red'
light.transition('off'); // false
light.state(); // 'red'
light.force_transition('off'); // true
light.state(); // 'off'
The state to switch to
The data change to insert during the transition
true if a transition (forced or otherwise) existed and occurred,
false otherwise.
Get the FSL language version this machine was compiled under.
The FSL version string.
Look up a transition's edge index by source and target state names.
Source state name.
Target state name.
The edge index in the edges array, or undefined if no
such transition exists.
Instruct the machine to complete a transition. Synonym for transition.
const light = sm`red -> green -> yellow -> red; [red yellow green] 'shutdown' ~> off 'start' -> red;`;
light.state(); // 'red'
light.go('green'); // true
light.state(); // 'green'
The state to switch to
The data change to insert during the transition
true if the transition was legal and occurred, false otherwise.
Get the graph layout direction (e.g. 'LR', 'TB'). Set via the
FSL graph_layout directive.
The layout string, or the default if not set.
Check whether any state in the machine is complete.
true if at least one state is complete.
Check whether the machine knows a given state.
import * as jssm from 'jssm';
const lswitch = jssm.from('on <=> off;');
console.log( lswitch.has_state('off') ); // true
console.log( lswitch.has_state('dance') ); // false
The state to be checked for existence.
true if the state exists, false otherwise.
Check whether any state in the machine is terminal.
true if at least one state has no exits.
Check whether any state in the machine is unenterable.
true if at least one state has no incoming transitions.
Register a pre-transition hook on a specific edge. Fires before
transitioning from from to to. If the handler returns false, the
transition is blocked.
const m = sm`a -> b -> c;`;
m.hook('a', 'b', () => console.log('a->b'));
Source state name.
Target state name.
Callback invoked before the transition.
this for chaining.
Register a pre-transition hook on a specific action-labeled edge.
Source state name.
Target state name.
The action label that triggers this hook.
Callback invoked before the transition.
this for chaining.
Register a hook that fires after leaving a specific state (post-exit).
The state that was exited.
Callback invoked after exit completes.
this for chaining.
Register a pre-transition hook on any action-driven transition.
Callback invoked before any action transition.
this for chaining.
Register a pre-transition hook on any transition regardless of kind.
Callback invoked before every transition.
this for chaining.
Register a hook that fires when entering a specific state.
The state being entered.
Callback invoked on entry.
this for chaining.
Register a pre-transition hook that fires after all other pre-hooks
on every transition. If the handler returns false, the transition is
blocked. The handler receives an EverythingHookContext whose
hook_name is 'everything'.
const m = sm`a -> b -> c;`;
m.hook_everything(({ hook_name }) => {
console.log(`${hook_name} fired`);
return true;
});
Callback invoked after all other pre-hooks.
this for chaining.
Register a hook that fires when leaving a specific state.
The state being exited.
Callback invoked on exit.
this for chaining.
Register a pre-transition hook on any forced (~>) transition.
Callback invoked before any forced transition.
this for chaining.
Register a pre-transition hook on any edge triggered by a specific action.
The action name to hook.
Callback invoked before any transition with this action.
this for chaining.
Register a pre-transition hook on any main-path (=>) transition.
Callback invoked before any main transition.
this for chaining.
Register a post-transition hook that fires after all other
post-hooks on every transition. Cannot block the transition. The
handler receives an EverythingHookContext whose hook_name is
'post everything'.
const m = sm`a -> b -> c;`;
m.hook_post_everything(({ hook_name }) => {
console.log(`${hook_name} fired`);
});
Callback invoked after all other post-hooks.
this for chaining.
Register a pre-transition hook that fires before all other pre-hooks
on every transition. If the handler returns false, the transition is
blocked. The handler receives an EverythingHookContext whose
hook_name is 'pre everything'.
const m = sm`a -> b -> c;`;
m.hook_pre_everything(({ hook_name }) => {
console.log(`${hook_name} fired`);
return true;
});
Callback invoked before all other pre-hooks.
this for chaining.
Register a post-transition hook that fires before all other
post-hooks on every transition. Cannot block the transition. The
handler receives an EverythingHookContext whose hook_name is
'pre post everything'.
const m = sm`a -> b -> c;`;
m.hook_pre_post_everything(({ hook_name }) => {
console.log(`${hook_name} fired`);
});
Callback invoked before all other post-hooks.
this for chaining.
Register a pre-transition hook on any standard (->) transition.
Callback invoked before any legal transition.
this for chaining.
Get the instance name of this machine, if one was assigned at creation.
The instance name string, or undefined.
Check whether the current state is complete (every exit has an action).
true if the current state is complete.
Check whether a given state is a valid start state (either because it was explicitly named as such, or because it was the first mentioned state.)
import { sm, is_end_state } from 'jssm';
const example = sm`a -> b;`;
console.log( final_test.is_start_state('a') ); // false
console.log( final_test.is_start_state('b') ); // true
const example = sm`end_states: [a b]; a -> b;`;
console.log( final_test.is_start_state('a') ); // true
console.log( final_test.is_start_state('b') ); // true
The name of the state to check
Check whether the current state is final (either has no exits or is marked
complete.)
import { sm, is_final } from 'jssm';
const final_test = sm`first -> second;`;
console.log( final_test.is_final() ); // false
state.transition('second');
console.log( final_test.is_final() ); // true
Check whether a given state is a valid start state (either because it was explicitly named as such, or because it was the first mentioned state.)
import { sm, is_start_state } from 'jssm';
const example = sm`a -> b;`;
console.log( final_test.is_start_state('a') ); // true
console.log( final_test.is_start_state('b') ); // false
const example = sm`start_states: [a b]; a -> b;`;
console.log( final_test.is_start_state('a') ); // true
console.log( final_test.is_start_state('b') ); // true
The name of the state to check
Check whether the current state is terminal (has no exits).
true if the current state has zero exits.
Check whether a state has no incoming transitions (unreachable after start).
The state to check.
true if the state has zero entrances.
Check whether a given string is a known property's name.
const example = sm`property foo default 1; a->b;`;
example.known_prop('foo'); // true
example.known_prop('bar'); // false
The relevant property name to look up
List all known property names. If you'd also like values, use props instead. The order of the properties is not defined, and the properties generally will not be sorted.
const m = sm`property color default "grey"; property size default 1; a -> b;`;
m.known_props(); // ['color', 'size']
An array of all property name strings defined on this machine.
Get the label for a given state, if any; return undefined otherwise.
import * as jssm from 'jssm';
const lswitch = jssm.from('a -> b; state a: { label: "Foo!"; };');
console.log( lswitch.label_for('a') ); // 'Foo!'
console.log( lswitch.label_for('b') ); // undefined
See also display_text.
The state to get the label for.
The label string, or undefined if no label is set.
List all distinct action names defined anywhere in the machine.
An array of action name strings.
Lists all edges of a machine.
import { sm } from 'jssm';
const lswitch = sm`on 'toggle' <=> 'toggle' off;`;
lswitch.list_edges();
[
{
from: 'on',
to: 'off',
kind: 'main',
forced_only: false,
main_path: true,
action: 'toggle'
},
{
from: 'off',
to: 'on',
kind: 'main',
forced_only: false,
main_path: true,
action: 'toggle'
}
]
An array of all JssmTransition edge objects.
List all entrances attached to the current state. Please note that the order of the list is not defined. This list includes both unforced and forced entrances; if this isn't desired, consider {@link list_unforced_entrances} or {@link list_forced_entrances} as appropriate.
import { sm } from 'jssm';
const light = sm`red 'next' -> green 'next' -> yellow 'next' -> red; [red yellow green] 'shutdown' ~> off 'start' -> red;`;
light.state(); // 'red'
light.list_entrances(); // [ 'yellow', 'off' ]
The state whose entrances to have listed
List all action names available as exits from a given state.
The state to inspect. Defaults to the current state.
An array of action name strings.
List all exits attached to the current state. Please note that the order of the list is not defined. This list includes both unforced and forced exits; if this isn't desired, consider {@link list_unforced_exits} or {@link list_forced_exits} as appropriate.
import { sm } from 'jssm';
const light = sm`red 'next' -> green 'next' -> yellow 'next' -> red; [red yellow green] 'shutdown' ~> off 'start' -> red;`;
light.state(); // 'red'
light.list_exits(); // [ 'green', 'off' ]
The state whose exits to have listed
Get the map of named transitions (transitions with explicit names).
A Map from transition name to edge index.
List all states that have a specific action attached. Please note that the order of the states is not guaranteed.
import { sm } from 'jssm';
const machine = sm`
red 'next' -> green 'next' -> yellow 'next' -> red;
[red yellow green] 'shutdown' ~> off 'start' -> red;
`;
console.log( machine.list_states_having_action('next') ); // ['red', 'green', 'yellow']
console.log( machine.list_states_having_action('start') ); // ['off']
The action to be checked for associated states
List all transitions attached to the current state, sorted by entrance and exit. The order of each sublist is not defined. A node could appear in both lists.
import { sm } from 'jssm';
const light = sm`red 'next' -> green 'next' -> yellow 'next' -> red; [red yellow green] 'shutdown' ~> off 'start' -> red;`;
light.state(); // 'red'
light.list_transitions(); // { entrances: [ 'yellow', 'off' ], exits: [ 'green', 'off' ] }
The state whose transitions to have listed
Look up the full transition object for a given source→target pair.
Source state name.
Target state name.
The JssmTransition object, or undefined if none exists.
Get the machine's author list. Set via the FSL machine_author directive.
An array of author name strings.
Get the machine's comment string. Set via the FSL machine_comment directive.
The comment string.
Get the machine's contributor list. Set via the FSL machine_contributor directive.
An array of contributor name strings.
Get the machine's definition string. Set via the FSL machine_definition directive.
The definition string.
Get the machine's language (ISO 639-1). Set via the FSL machine_language directive.
The language code string.
Get the machine's license string. Set via the FSL machine_license directive.
The license string.
Get the machine's name. Set via the FSL machine_name directive.
The machine name string.
Get the complete internal state of the machine as a serializable structure. Includes actions, edges, edge map, named transitions, reverse actions, current state, and states map.
A JssmMachineInternalState snapshot.
Get the machine's version string. Set via the FSL machine_version directive.
The version string.
Replace the current state and data with no regard to the graph.
import { sm } from 'jssm';
const machine = sm`a -> b -> c;`;
console.log( machine.state() ); // 'a'
machine.go('b');
machine.go('c');
console.log( machine.state() ); // 'c'
machine.override('a');
console.log( machine.state() ); // 'a'
Post-transition hook on a specific edge. Fires after the transition
from from to to has completed. Cannot block the transition.
Source state name.
Target state name.
Callback invoked after the transition.
this for chaining.
Post-transition hook on a specific action-labeled edge.
Source state name.
Target state name.
The action label.
Callback invoked after the transition.
this for chaining.
Post-transition hook on any action-driven transition.
Callback invoked after any action transition.
this for chaining.
Post-transition hook on any transition regardless of kind.
Callback invoked after every transition.
this for chaining.
Post-transition hook that fires after entering a specific state.
The state that was entered.
Callback invoked after entry.
this for chaining.
Post-transition hook that fires after leaving a specific state.
The state that was exited.
Callback invoked after exit.
this for chaining.
Post-transition hook on any forced (~>) transition.
Callback invoked after any forced transition.
this for chaining.
Post-transition hook on any edge triggered by a specific action.
The action name.
Callback invoked after any transition with this action.
this for chaining.
Post-transition hook on any main-path (=>) transition.
Callback invoked after any main transition.
this for chaining.
Post-transition hook on any standard (->) transition.
Callback invoked after any legal transition.
this for chaining.
Take n probabilistic steps and return a histograph of how many times
each state was visited.
Number of steps to walk.
A Map from state name to visit count.
Take a single random transition from the current state, weighted by edge probabilities.
true if a transition was taken, false otherwise.
Take n consecutive probabilistic transitions and return the sequence
of states visited (before each transition).
Number of steps to walk.
An array of state names visited during the walk.
List all action exits from a state with their probabilities.
The state to inspect. Defaults to the current state.
An array of { action, probability } objects.
Get the transitions available from a state, filtered to those with probability data. Used by the probabilistic walk system.
The state to inspect.
An array of JssmTransition edges exiting the state.
Get the current value of a given property name. Checks the current
state's properties first, then falls back to the global default.
Returns undefined if neither exists. For a throwing variant, see
strict_prop.
const m = sm`property color default "grey"; a -> b;
state b: { property color "blue"; };`;
m.prop('color'); // 'grey' (default, because state is 'a')
m.go('b');
m.prop('color'); // 'blue' (state 'b' overrides the default)
m.prop('size'); // undefined (no such property)
The relevant property name to look up.
The value behind the prop name, or undefined if not defined.
Get the current value of every prop, as an object. If no current definition
exists for a prop — that is, if the prop was defined without a default and
the current state also doesn't define the prop — then that prop will be listed
in the returned object with a value of undefined.
const traffic_light = sm`
property can_go default true;
property hesitate default true;
property stop_first default false;
Off -> Red => Green => Yellow => Red;
[Red Yellow Green] ~> [Off FlashingRed];
FlashingRed -> Red;
state Red: { property stop_first true; property can_go false; };
state Off: { property stop_first true; };
state FlashingRed: { property stop_first true; };
state Green: { property hesitate false; };
`;
traffic_light.state(); // Off
traffic_light.props(); // { can_go: true, hesitate: true, stop_first: true; }
traffic_light.go('Red');
traffic_light.props(); // { can_go: false, hesitate: true, stop_first: true; }
traffic_light.go('Green');
traffic_light.props(); // { can_go: true, hesitate: false, stop_first: false; }
An object mapping every known property name to its current value
(or undefined if the property has no default and the current state
doesn't define it).
Get the raw state declaration objects as parsed from the FSL source.
An array of raw state declaration objects.
Serialize the current machine, including all defining state but not the machine string, to a structure. This means you will need the machine string to recreate (to not waste repeated space;) if you want the machine string embedded, call {@link serialize_with_string} instead.
An optional comment string to embed in the serialized output for identification or debugging.
A JssmSerialization object containing the machine's current state, data, and timestamp.
Low-level hook registration. Installs a handler described by a HookDescription into the appropriate internal map. Prefer the convenience wrappers (hook, hook_entry, etc.) over calling this directly.
A hook descriptor specifying kind, states, and handler.
Schedule an automatic transition to next_state after after_time
milliseconds. Only one timeout may be active at a time.
The state to transition to when the timer fires.
Delay in milliseconds.
Convenience method to create a new machine from a tagged template literal.
Equivalent to calling the top-level sm function.
The template string array.
Interpolated values.
A new Machine instance.
Get the current state of a machine.
import * as jssm from 'jssm';
const lswitch = jssm.from('on <=> off;');
console.log( lswitch.state() ); // 'on'
lswitch.transition('off');
console.log( lswitch.state() ); // 'off'
The current state name.
Get the processed state declaration for a specific state.
The state to look up.
The JssmStateDeclaration for the given state.
Get all processed state declarations as a Map.
A Map from state name to JssmStateDeclaration.
Get the internal state descriptor for a given state name.
The state to look up.
The JssmGenericState descriptor.
Check whether a specific state is complete (every exit has an action).
The state to check.
true if the state is complete.
Check whether a given state is final (either has no exits or is marked
complete.)
import { sm, state_is_final } from 'jssm';
const final_test = sm`first -> second;`;
console.log( final_test.state_is_final('first') ); // false
console.log( final_test.state_is_final('second') ); // true
The name of the state to check for finality
Check whether a specific state is terminal (has no exits).
The state to check.
true if the state has zero exits.
Get the configured after timeout for a given state, if any.
The state to look up.
A [targetState, delayMs] tuple, or undefined if no timeout
is configured for that state.
List all the states known by the machine. Please note that the order of these states is not guaranteed.
import * as jssm from 'jssm';
const lswitch = jssm.from('on <=> off;');
console.log( lswitch.states() ); // ['on', 'off']
An array of all state names in the machine.
Get the current value of a given property name. If missing on the state
and without a global default, throws a JssmError, unlike
prop, which would return undefined instead.
const m = sm`property color default "grey"; a -> b;`;
m.strict_prop('color'); // 'grey'
m.strict_prop('size'); // throws JssmError
The relevant property name to look up.
The value behind the prop name.
Gets the composite style for a specific node by individually imposing the style layers on a given object, after determining which layers are appropriate.
The order of composition is base, then theme, then user content. Each item in the stack will be composited independently. First, the base state style, then the theme state style, then the user state style.
After the three state styles, we'll composite the hooked styles; then the terminal styles; then the start styles; then the end styles; finally, the active styles. Remember, last wins.
The base state style must exist. All other styles are optional.
The state to compute the composite style for.
The fully composited JssmStateConfig for the given state.
Instruct the machine to complete a transition. Synonym for go.
const light = sm`
off 'start' -> red;
red 'next' -> green 'next' -> yellow 'next' -> red;
[red yellow green] 'shutdown' ~> off;
`;
light.state(); // 'off'
light.go('red'); // true
light.state(); // 'red'
light.go('green'); // true
light.state(); // 'green'
light.go('blue'); // !! false - no such state
light.state(); // 'green'
light.go('red'); // !! false - green may not go directly to red, only to yellow
light.state(); // 'green'
The state to switch to
The data change to insert during the transition
true if the transition was legal and occurred, false otherwise.
Shared transition core used by transition, force_transition, and action. Runs validation, fires the full hook pipeline (pre- everything, any-action, after, any-transition, exit, named, basic, edge-type, entry, everything), commits the new state if nothing rejected, and returns whether the transition succeeded.
Not meant for external use. Call one of the public wrappers instead:
transition for an ordinary legal transitionforce_transition to bypass the legality checkaction to dispatch by action name rather than target stateThe target state name (for a plain or forced
transition) or the action name (when wasAction is true).
Optional replacement machine data to install alongside the transition. Hooks may further override this via complex results.
true if the caller invoked force_transition, in
which case legality is checked against valid_force_transition rather
than valid_transition.
true if the caller invoked action, in which case
newStateOrAction is an action name and the target state is looked up
via the current action edge.
true if the transition was valid and every hook passed;
false if the transition was invalid or any hook rejected.
Check whether an action is available from the current state.
The action name to check.
Reserved for future data validation.
true if the action can be taken.
Check whether a forced transition to a given state exists from the current state.
The target state.
Reserved for future data validation.
true if a forced (or any) transition exists.
Check whether a transition to a given state is legal (non-forced) from the current state.
The target state.
Reserved for future data validation.
true if the transition is legal.
Generated using TypeDoc
Core finite state machine class. Holds the full graph of states and transitions, the current state, hooks, data, properties, and all runtime behavior. Typically created via the sm tagged template literal rather than constructed directly.