@flighthq/statechart 0.5.1-next.973.788d3d7 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (66) hide show
  1. package/README.md +2 -2
  2. package/dist/.tsbuildinfo.contract +1 -0
  3. package/dist/.tsbuildinfo.runtime +1 -0
  4. package/dist/contract.d.ts +7 -4
  5. package/dist/contract.d.ts.map +1 -1
  6. package/dist/contract.js +8 -4
  7. package/dist/contract.js.map +1 -1
  8. package/dist/contract.statechart-types.d.ts +3 -0
  9. package/dist/contract.statechart-types.d.ts.map +1 -0
  10. package/dist/contract.statechart-types.js +4 -0
  11. package/dist/contract.statechart-types.js.map +1 -0
  12. package/dist/enableStatechartGuards.d.ts +5 -4
  13. package/dist/enableStatechartGuards.d.ts.map +1 -1
  14. package/dist/enableStatechartGuards.js +11 -4
  15. package/dist/enableStatechartGuards.js.map +1 -1
  16. package/dist/index.d.ts +3 -3
  17. package/dist/index.d.ts.map +1 -1
  18. package/dist/index.js +4 -3
  19. package/dist/index.js.map +1 -1
  20. package/dist/statechart.d.ts +13 -12
  21. package/dist/statechart.d.ts.map +1 -1
  22. package/dist/statechart.js +302 -263
  23. package/dist/statechart.js.map +1 -1
  24. package/dist/statechartCompat.d.ts +46 -0
  25. package/dist/statechartCompat.d.ts.map +1 -0
  26. package/dist/statechartCompat.js +127 -0
  27. package/dist/statechartCompat.js.map +1 -0
  28. package/dist/statechartInstanceFields.d.ts +3 -0
  29. package/dist/statechartInstanceFields.d.ts.map +1 -0
  30. package/dist/statechartInstanceFields.js +13 -0
  31. package/dist/statechartInstanceFields.js.map +1 -0
  32. package/dist/statechartInstanceInit.d.ts +4 -0
  33. package/dist/statechartInstanceInit.d.ts.map +1 -0
  34. package/dist/statechartInstanceInit.js +7 -0
  35. package/dist/statechartInstanceInit.js.map +1 -0
  36. package/dist/statechartRuntime.d.ts +9 -0
  37. package/dist/statechartRuntime.d.ts.map +1 -0
  38. package/dist/statechartRuntime.js +25 -0
  39. package/dist/statechartRuntime.js.map +1 -0
  40. package/dist/statechartSignalEmit.d.ts +3 -0
  41. package/dist/statechartSignalEmit.d.ts.map +1 -0
  42. package/dist/statechartSignalEmit.js +7 -0
  43. package/dist/statechartSignalEmit.js.map +1 -0
  44. package/dist/statechartSignals.d.ts +4 -3
  45. package/dist/statechartSignals.d.ts.map +1 -1
  46. package/dist/statechartSignals.js +2 -2
  47. package/dist/statechartSignals.js.map +1 -1
  48. package/dist/statechartTypedArrays.d.ts +4 -0
  49. package/dist/statechartTypedArrays.d.ts.map +1 -0
  50. package/dist/statechartTypedArrays.js +10 -0
  51. package/dist/statechartTypedArrays.js.map +1 -0
  52. package/dist/types.d.ts +85 -0
  53. package/dist/types.d.ts.map +1 -0
  54. package/dist/types.js +33 -0
  55. package/dist/types.js.map +1 -0
  56. package/package.json +7 -6
  57. package/src/enableStatechartGuards.test.ts +26 -17
  58. package/src/statechart.test.ts +434 -291
  59. package/src/statechartCompat.test.ts +165 -0
  60. package/src/statechartInstanceFields.test.ts +36 -0
  61. package/src/statechartInstanceInit.test.ts +20 -0
  62. package/src/statechartIntegerDomain.test.ts +57 -0
  63. package/src/statechartRuntime.test.ts +55 -0
  64. package/src/statechartSignalEmit.test.ts +19 -0
  65. package/src/statechartSignals.test.ts +9 -9
  66. package/src/statechartTypedArrays.test.ts +25 -0
@@ -1,369 +1,408 @@
1
- import { allocateEntity, finishEntity } from '@flighthq/entity/contract';
2
- import { StatechartComparison, StatechartInputKind, StatechartTransitionStatus } from '@flighthq/types/contract';
3
- // Advance every concurrent region by `deltaTime` milliseconds and return how many reached a new
4
- // state. Each region changes at most once per call. Trigger inputs are edge latches shared by all
5
- // regions for the whole pass, then cleared, so one fired trigger can independently drive several
6
- // regions. Blend progress is reported as a number only; this package never samples or blends content.
1
+ // Generated from crates/flight-statechart/src/statechart.rs by flight-compiler.
2
+ // Rust is authoritative; run `npm run generate` after changing it.
3
+ import { allocateEntity } from '@flighthq/entity/contract';
4
+ import { initializeStatechartInstanceFields } from './statechartInstanceFields.js';
5
+ import { isStatechartComparison, isStatechartInteger, isStatechartString, throwStatechartInputKindTypeError, throwStatechartTypeError, throwStatechartUnknownInputKindTypeError, } from './statechartRuntime.js';
6
+ import { emitStatechartStateChange } from './statechartSignalEmit.js';
7
+ import { createStatechartFloat32Array, createStatechartFloat64Array, createStatechartInt32Array, } from './statechartTypedArrays.js';
7
8
  export function advanceStatechartInstance(instance, deltaTime) {
8
- const deltaTimeMs = Number.isFinite(deltaTime) && deltaTime > 0 ? deltaTime : 0;
9
- let changedRegions = null;
10
- let changedRegionCount = 0;
11
- for (let regionIndex = 0; regionIndex < instance.chart.regions.length; regionIndex++) {
9
+ const deltaTimeMs = Number.isFinite(deltaTime) && deltaTime > 0.0 ? deltaTime : 0.0;
10
+ const chart = instance.chart;
11
+ const regionCount = chart.regions.length;
12
+ let changed = null;
13
+ let changedCount = 0;
14
+ for (let regionIndex = 0; regionIndex < regionCount; regionIndex += 1) {
12
15
  const previousStateIndex = instance.regionStates[regionIndex];
13
- if (advanceStatechartRegion(instance, regionIndex, deltaTimeMs)) {
14
- changedRegionCount++;
15
- // Observer allocation is opt-in and occurs only when a state actually changes. Pairs are
16
- // [regionIndex, previousStateIndex]; the new state is already in regionStates.
17
- if (instance.signals !== null)
18
- (changedRegions ??= []).push(regionIndex, previousStateIndex);
16
+ if (advanceStatechartRegion(instance, chart, regionIndex | 0, deltaTimeMs)) {
17
+ changedCount += 1;
18
+ if (instance.signals !== null) {
19
+ if (changed === null) {
20
+ changed = [];
21
+ }
22
+ const activeChanged = changed;
23
+ activeChanged.push(regionIndex | 0);
24
+ activeChanged.push(previousStateIndex);
25
+ }
19
26
  }
20
27
  }
21
- // Clear before emitting: a listener may fire a trigger for the NEXT pass, and that edge must not be
22
- // erased by cleanup from this pass. Deferring every emit also prevents a region-0 listener from
23
- // mutating an input while later concurrent regions are still evaluating the shared input snapshot.
24
- clearStatechartTriggers(instance);
25
- if (changedRegions !== null && instance.signals !== null) {
26
- for (let i = 0; i < changedRegions.length; i += 2) {
27
- const regionIndex = changedRegions[i];
28
- instance.signals.onStateChange.emit(regionIndex, changedRegions[i + 1], instance.regionStates[regionIndex]);
28
+ clearStatechartTriggers(instance, chart);
29
+ const signals = instance.signals;
30
+ if (signals !== null) {
31
+ const activeSignals = signals;
32
+ if (changed !== null) {
33
+ const activeChanged = changed;
34
+ let changedIndex = 0;
35
+ while (changedIndex < activeChanged.length) {
36
+ const regionIndex = activeChanged[changedIndex];
37
+ const previousStateIndex = activeChanged[changedIndex + 1];
38
+ const newStateIndex = instance.regionStates[regionIndex >>> 0];
39
+ emitStatechartStateChange(activeSignals, regionIndex, previousStateIndex, newStateIndex);
40
+ changedIndex += 2;
41
+ }
29
42
  }
30
43
  }
31
- return changedRegionCount;
44
+ return changedCount;
32
45
  }
33
46
  export function createStatechartInstance(chart) {
34
- const out = allocateEntity();
35
- initializeStatechartInstance(out, chart);
36
- return finishEntity(out);
47
+ let out = allocateEntity();
48
+ initializeStatechartInstancePortable(out, chart);
49
+ return out;
37
50
  }
38
- // Explain what the next advance sees in one region. This is the shakeable diagnostic companion to
39
- // sentinel/count-based runtime calls: it reports an active blend, the first ready transition, or the
40
- // first authored transition's blocking condition/exit time without mutating the instance.
41
51
  export function explainStatechartTransition(instance, regionIndex) {
42
- const region = instance.chart.regions[regionIndex];
43
- if (region === undefined)
52
+ if (!isStatechartInteger(regionIndex) || regionIndex < 0) {
53
+ return invalidRegionExplanation(regionIndex);
54
+ }
55
+ const ri = regionIndex >>> 0;
56
+ let chart = instance.chart;
57
+ if (ri >= chart.regions.length) {
44
58
  return invalidRegionExplanation(regionIndex);
45
- const sourceStateIndex = instance.regionStates[regionIndex];
46
- const state = region.states[sourceStateIndex];
47
- if (state === undefined)
59
+ }
60
+ const region = chart.regions[ri];
61
+ const sourceStateIndex = instance.regionStates[ri];
62
+ if (sourceStateIndex < 0 || sourceStateIndex >>> 0 >= region.states.length) {
48
63
  return invalidRegionExplanation(regionIndex);
49
- const activeTransitionIndex = instance.regionTransitions[regionIndex];
64
+ }
65
+ const state = region.states[sourceStateIndex >>> 0];
66
+ const activeTransitionIndex = instance.regionTransitions[ri];
50
67
  if (activeTransitionIndex >= 0) {
51
- const activeTransition = state.transitions[activeTransitionIndex];
52
- if (activeTransition === undefined)
68
+ if (activeTransitionIndex >>> 0 >= state.transitions.length) {
53
69
  return invalidRegionExplanation(regionIndex);
70
+ }
71
+ const active = state.transitions[activeTransitionIndex >>> 0];
54
72
  return {
55
- blend: instance.regionBlend[regionIndex],
73
+ blend: instance.regionBlend[ri],
56
74
  conditionIndex: -1,
57
- regionIndex,
58
- sourceStateIndex,
59
- status: StatechartTransitionStatus.Transitioning,
60
- targetStateIndex: activeTransition.targetStateIndex,
75
+ regionIndex: regionIndex,
76
+ sourceStateIndex: sourceStateIndex,
77
+ status: 'Transitioning',
78
+ targetStateIndex: active.targetStateIndex,
61
79
  transitionIndex: activeTransitionIndex,
62
80
  };
63
81
  }
64
82
  if (state.transitions.length === 0) {
65
83
  return {
66
- blend: 0,
84
+ blend: 0.0,
67
85
  conditionIndex: -1,
68
- regionIndex,
69
- sourceStateIndex,
70
- status: StatechartTransitionStatus.NoTransitions,
86
+ regionIndex: regionIndex,
87
+ sourceStateIndex: sourceStateIndex,
88
+ status: 'NoTransitions',
71
89
  targetStateIndex: -1,
72
90
  transitionIndex: -1,
73
91
  };
74
92
  }
75
93
  let firstBlocked = null;
76
- for (let transitionIndex = 0; transitionIndex < state.transitions.length; transitionIndex++) {
94
+ for (let transitionIndex = 0; transitionIndex < state.transitions.length; transitionIndex += 1) {
77
95
  const transition = state.transitions[transitionIndex];
78
- const conditionIndex = getFirstUnmetCondition(instance, transition);
96
+ const conditionIndex = getFirstUnmetCondition(instance, chart, transition);
79
97
  if (conditionIndex >= 0) {
80
- firstBlocked ??= {
81
- blend: 0,
82
- conditionIndex,
83
- regionIndex,
84
- sourceStateIndex,
85
- status: StatechartTransitionStatus.ConditionsUnmet,
86
- targetStateIndex: transition.targetStateIndex,
87
- transitionIndex,
88
- };
98
+ if (firstBlocked === null) {
99
+ firstBlocked = {
100
+ blend: 0.0,
101
+ conditionIndex: conditionIndex,
102
+ regionIndex: regionIndex,
103
+ sourceStateIndex: sourceStateIndex,
104
+ status: 'ConditionsUnmet',
105
+ targetStateIndex: transition.targetStateIndex,
106
+ transitionIndex: transitionIndex | 0,
107
+ };
108
+ }
89
109
  continue;
90
110
  }
91
- const exitStatus = getStatechartExitStatus(instance, regionIndex, transition);
92
- if (exitStatus === StatechartTransitionStatus.MissingRegionDuration) {
111
+ const exitStatus = getStatechartExitStatus(instance, ri, transition);
112
+ if (exitStatus === 'MissingRegionDuration') {
93
113
  return {
94
- blend: 0,
114
+ blend: 0.0,
95
115
  conditionIndex: -1,
96
- regionIndex,
97
- sourceStateIndex,
98
- status: StatechartTransitionStatus.MissingRegionDuration,
116
+ regionIndex: regionIndex,
117
+ sourceStateIndex: sourceStateIndex,
118
+ status: 'MissingRegionDuration',
99
119
  targetStateIndex: transition.targetStateIndex,
100
- transitionIndex,
120
+ transitionIndex: transitionIndex | 0,
101
121
  };
102
122
  }
103
- if (exitStatus === StatechartTransitionStatus.ExitTimePending) {
104
- firstBlocked ??= {
105
- blend: 0,
106
- conditionIndex: -1,
107
- regionIndex,
108
- sourceStateIndex,
109
- status: StatechartTransitionStatus.ExitTimePending,
110
- targetStateIndex: transition.targetStateIndex,
111
- transitionIndex,
112
- };
123
+ if (exitStatus === 'ExitTimePending') {
124
+ if (firstBlocked === null) {
125
+ firstBlocked = {
126
+ blend: 0.0,
127
+ conditionIndex: -1,
128
+ regionIndex: regionIndex,
129
+ sourceStateIndex: sourceStateIndex,
130
+ status: 'ExitTimePending',
131
+ targetStateIndex: transition.targetStateIndex,
132
+ transitionIndex: transitionIndex | 0,
133
+ };
134
+ }
113
135
  continue;
114
136
  }
115
137
  return {
116
- blend: 0,
138
+ blend: 0.0,
117
139
  conditionIndex: -1,
118
- regionIndex,
119
- sourceStateIndex,
120
- status: StatechartTransitionStatus.Ready,
140
+ regionIndex: regionIndex,
141
+ sourceStateIndex: sourceStateIndex,
142
+ status: 'Ready',
121
143
  targetStateIndex: transition.targetStateIndex,
122
- transitionIndex,
144
+ transitionIndex: transitionIndex | 0,
123
145
  };
124
146
  }
125
147
  return firstBlocked;
126
148
  }
127
- // Latch a Trigger input for the next whole-region advance. Trigger conditions ignore their authored
128
- // comparison/value and test only this latch. Invalid indices and kind mismatches are programmer errors.
129
- export function fireStatechartTrigger(instance, inputIndex) {
130
- assertStatechartInputKind(instance, inputIndex, StatechartInputKind.Trigger);
131
- instance.inputValues[inputIndex] = 1;
132
- }
133
- // Return the first input with `name`, or -1 when it is absent. Authored duplicate names deliberately
134
- // preserve array/serialization order rather than building hidden lookup state.
135
- export function getStatechartInputIndex(chart, name) {
136
- for (let inputIndex = 0; inputIndex < chart.inputs.length; inputIndex++) {
137
- if (chart.inputs[inputIndex].name === name)
138
- return inputIndex;
139
- }
140
- return -1;
141
- }
142
- // Return one concurrent region's target-state blend weight in [0, 1], or -1 for an invalid region.
143
- // The composition layer decides what the plain number means; statechart performs no animation work.
144
- export function getStatechartRegionBlend(instance, regionIndex) {
145
- return regionIndex >= 0 && regionIndex < instance.regionBlend.length ? instance.regionBlend[regionIndex] : -1;
146
- }
147
- // Return one concurrent region's current source-state index, or -1 for an invalid region.
148
- export function getStatechartRegionState(instance, regionIndex) {
149
- return regionIndex >= 0 && regionIndex < instance.regionStates.length ? instance.regionStates[regionIndex] : -1;
150
- }
151
- // Allocate the mutable per-actor half of `chart`. The chart itself is retained by reference and is
152
- // never mutated; input and region state live in independent typed arrays so one chart can drive many
153
- // actors. Malformed authored indices/kinds are programmer errors and fail at this construction seam.
154
- export function initializeStatechartInstance(out, chart) {
155
- validateStatechart(chart);
156
- const inputValues = new Float64Array(chart.inputs.length);
157
- for (let inputIndex = 0; inputIndex < chart.inputs.length; inputIndex++) {
158
- const input = chart.inputs[inputIndex];
159
- inputValues[inputIndex] =
160
- input.kind === StatechartInputKind.Boolean ? (input.initialValue === 0 ? 0 : 1) : input.initialValue;
161
- }
162
- const regionCount = chart.regions.length;
163
- const regionBlend = new Float32Array(regionCount);
164
- const regionDuration = new Float64Array(regionCount);
165
- const regionElapsed = new Float64Array(regionCount);
166
- const regionStates = new Int32Array(regionCount);
167
- const regionTransitions = new Int32Array(regionCount);
168
- regionTransitions.fill(-1);
169
- for (let regionIndex = 0; regionIndex < regionCount; regionIndex++) {
170
- regionStates[regionIndex] = chart.regions[regionIndex].initialStateIndex;
171
- }
172
- out.chart = chart;
173
- out.durationGuard = null;
174
- out.inputValues = inputValues;
175
- out.regionBlend = regionBlend;
176
- out.regionDuration = regionDuration;
177
- out.regionElapsed = regionElapsed;
178
- out.regionStates = regionStates;
179
- out.regionTransitions = regionTransitions;
180
- out.signals = null;
181
- }
182
- // Write a Boolean input as the numeric 0/1 vocabulary used by data-only transition conditions.
183
- export function setStatechartBooleanInput(instance, inputIndex, value) {
184
- assertStatechartInputKind(instance, inputIndex, StatechartInputKind.Boolean);
185
- instance.inputValues[inputIndex] = value ? 1 : 0;
186
- }
187
- // Write a Number input. Numbers remain exact authored/runtime values; comparisons happen only while
188
- // selecting a transition.
189
- export function setStatechartNumberInput(instance, inputIndex, value) {
190
- assertStatechartInputKind(instance, inputIndex, StatechartInputKind.Number);
191
- instance.inputValues[inputIndex] = value;
192
- }
193
- // Supply the current state's duration for exit-time evaluation, in the same millisecond unit as
194
- // advanceStatechartInstance. The composition layer owns what the duration means and where it came from;
195
- // statechart only divides elapsed time by this plain number. Zero explicitly marks duration unavailable.
196
- export function setStatechartRegionDuration(instance, regionIndex, duration) {
197
- if (!Number.isInteger(regionIndex) || regionIndex < 0 || regionIndex >= instance.regionDuration.length) {
198
- throw new RangeError(`Statechart region index ${regionIndex} is out of range`);
199
- }
200
- if (!Number.isFinite(duration) || duration < 0) {
201
- throw new RangeError('Statechart region duration must be finite and non-negative');
202
- }
203
- instance.regionDuration[regionIndex] = duration;
204
- }
205
- function advanceStatechartRegion(instance, regionIndex, deltaTimeMs) {
206
- const region = instance.chart.regions[regionIndex];
207
- const sourceStateIndex = instance.regionStates[regionIndex];
208
- const sourceState = region.states[sourceStateIndex];
209
- if (sourceState === undefined)
210
- throw new RangeError(`Statechart region ${regionIndex} has an invalid active state`);
211
- instance.regionElapsed[regionIndex] += deltaTimeMs;
212
- let transitionIndex = instance.regionTransitions[regionIndex];
213
- let transition;
149
+ function advanceStatechartRegion(instance, chart, regionIndex, deltaTimeMs) {
150
+ const ri = regionIndex >>> 0;
151
+ const sourceStateIndex = instance.regionStates[ri];
152
+ let transitionIndex = instance.regionTransitions[ri];
153
+ const sourceTransitionCount = getStatechartTransitionCount(chart, regionIndex, sourceStateIndex);
154
+ instance.regionElapsed[ri] += deltaTimeMs;
214
155
  if (transitionIndex >= 0) {
215
- transition = sourceState.transitions[transitionIndex];
216
- if (transition === undefined) {
156
+ if (transitionIndex >>> 0 >= sourceTransitionCount) {
217
157
  throw new RangeError(`Statechart region ${regionIndex} has an invalid active transition`);
218
158
  }
219
159
  }
220
160
  else {
221
- transitionIndex = getReadyTransitionIndex(instance, regionIndex);
222
- if (transitionIndex < 0)
161
+ transitionIndex = getReadyTransitionIndex(instance, chart, regionIndex);
162
+ if (transitionIndex < 0) {
223
163
  return false;
224
- transition = sourceState.transitions[transitionIndex];
225
- instance.regionTransitions[regionIndex] = transitionIndex;
226
- instance.regionBlend[regionIndex] = 0;
164
+ }
165
+ let current = instance;
166
+ current.regionTransitions[ri] = transitionIndex;
167
+ current.regionBlend[ri] = 0.0;
227
168
  }
228
- const durationMs = Number.isFinite(transition.durationMs) && transition.durationMs > 0 ? transition.durationMs : 0;
229
- const blend = durationMs === 0 ? 1 : Math.min(1, instance.regionBlend[regionIndex] + deltaTimeMs / durationMs);
230
- instance.regionBlend[regionIndex] = blend;
231
- if (blend < 1)
169
+ let durationMs = chart.regions[ri].states[sourceStateIndex >>> 0].transitions[transitionIndex >>> 0].durationMs;
170
+ const target = chart.regions[ri].states[sourceStateIndex >>> 0].transitions[transitionIndex >>> 0].targetStateIndex;
171
+ durationMs = Number.isFinite(durationMs) && durationMs > 0.0 ? durationMs : 0.0;
172
+ const blend = durationMs === 0.0 ? 1.0 : Math.min(instance.regionBlend[ri] + deltaTimeMs / durationMs, 1.0);
173
+ instance.regionBlend[ri] = blend;
174
+ if (blend < 1.0) {
232
175
  return false;
233
- instance.regionStates[regionIndex] = transition.targetStateIndex;
234
- instance.regionTransitions[regionIndex] = -1;
235
- instance.regionBlend[regionIndex] = 0;
236
- instance.regionDuration[regionIndex] = 0;
237
- instance.regionElapsed[regionIndex] = 0;
176
+ }
177
+ let current = instance;
178
+ current.regionStates[ri] = target;
179
+ current.regionTransitions[ri] = -1;
180
+ current.regionBlend[ri] = 0.0;
181
+ current.regionDuration[ri] = 0.0;
182
+ current.regionElapsed[ri] = 0.0;
238
183
  return true;
239
184
  }
240
185
  function assertStatechartInputKind(instance, inputIndex, expectedKind) {
241
- const input = instance.chart.inputs[inputIndex];
242
- if (input === undefined)
186
+ const chart = instance.chart;
187
+ const inputCount = chart.inputs.length;
188
+ if (!isStatechartInteger(inputIndex) || inputIndex < 0 || inputIndex >>> 0 >= inputCount) {
243
189
  throw new RangeError(`Statechart input index ${inputIndex} is out of range`);
244
- if (input.kind !== expectedKind) {
245
- throw new TypeError(`Statechart input ${inputIndex} is ${input.kind}, not ${expectedKind}`);
190
+ }
191
+ const kind = chart.inputs[inputIndex >>> 0].kind;
192
+ if (kind !== expectedKind) {
193
+ throwStatechartInputKindTypeError(inputIndex, kind, expectedKind);
246
194
  }
247
195
  }
248
- function clearStatechartTriggers(instance) {
249
- for (let inputIndex = 0; inputIndex < instance.chart.inputs.length; inputIndex++) {
250
- if (instance.chart.inputs[inputIndex].kind === StatechartInputKind.Trigger)
251
- instance.inputValues[inputIndex] = 0;
196
+ function clearStatechartTriggers(instance, chart) {
197
+ let current = instance;
198
+ let inputIndex = 0;
199
+ while (inputIndex < chart.inputs.length) {
200
+ if (chart.inputs[inputIndex].kind === 'Trigger') {
201
+ current.inputValues[inputIndex] = 0.0;
202
+ }
203
+ inputIndex += 1;
252
204
  }
253
205
  }
254
206
  function compareStatechartCondition(value, condition) {
255
- switch (condition.comparison) {
256
- case StatechartComparison.Equal:
257
- return value === condition.value;
258
- case StatechartComparison.GreaterThan:
259
- return value > condition.value;
260
- case StatechartComparison.GreaterThanOrEqual:
261
- return value >= condition.value;
262
- case StatechartComparison.LessThan:
263
- return value < condition.value;
264
- case StatechartComparison.LessThanOrEqual:
265
- return value <= condition.value;
266
- case StatechartComparison.NotEqual:
267
- return value !== condition.value;
207
+ return (() => {
208
+ const matchValue = condition.comparison;
209
+ switch (matchValue) {
210
+ case 'Equal':
211
+ return value === condition.value;
212
+ case 'GreaterThan':
213
+ return value > condition.value;
214
+ case 'GreaterThanOrEqual':
215
+ return value >= condition.value;
216
+ case 'LessThan':
217
+ return value < condition.value;
218
+ case 'LessThanOrEqual':
219
+ return value <= condition.value;
220
+ case 'NotEqual':
221
+ return value !== condition.value;
222
+ }
223
+ })();
224
+ }
225
+ export function fireStatechartTrigger(instance, inputIndex) {
226
+ assertStatechartInputKind(instance, inputIndex, 'Trigger');
227
+ let current = instance;
228
+ current.inputValues[inputIndex >>> 0] = 1.0;
229
+ }
230
+ export function getStatechartInputIndex(chart, name) {
231
+ for (let inputIndex = 0; inputIndex < chart.inputs.length; inputIndex += 1) {
232
+ if (chart.inputs[inputIndex].name === name) {
233
+ return inputIndex | 0;
234
+ }
268
235
  }
236
+ return -1;
269
237
  }
270
- function getFirstUnmetCondition(instance, transition) {
271
- for (let conditionIndex = 0; conditionIndex < transition.conditions.length; conditionIndex++) {
238
+ function getFirstUnmetCondition(instance, chart, transition) {
239
+ for (let conditionIndex = 0; conditionIndex < transition.conditions.length; conditionIndex += 1) {
272
240
  const condition = transition.conditions[conditionIndex];
273
- const input = instance.chart.inputs[condition.inputIndex];
274
- if (input === undefined)
275
- return conditionIndex;
276
- const inputValue = instance.inputValues[condition.inputIndex];
277
- const met = input.kind === StatechartInputKind.Trigger ? inputValue !== 0 : compareStatechartCondition(inputValue, condition);
278
- if (!met)
279
- return conditionIndex;
241
+ if (condition.inputIndex < 0 || condition.inputIndex >>> 0 >= chart.inputs.length) {
242
+ return conditionIndex | 0;
243
+ }
244
+ const input = chart.inputs[condition.inputIndex >>> 0];
245
+ const inputValue = instance.inputValues[condition.inputIndex >>> 0];
246
+ const met = input.kind === 'Trigger' ? inputValue !== 0.0 : compareStatechartCondition(inputValue, condition);
247
+ if (!met) {
248
+ return conditionIndex | 0;
249
+ }
280
250
  }
281
251
  return -1;
282
252
  }
283
- function getReadyTransitionIndex(instance, regionIndex) {
284
- const region = instance.chart.regions[regionIndex];
285
- const state = region.states[instance.regionStates[regionIndex]];
286
- for (let transitionIndex = 0; transitionIndex < state.transitions.length; transitionIndex++) {
287
- const transition = state.transitions[transitionIndex];
288
- if (getFirstUnmetCondition(instance, transition) >= 0)
289
- continue;
290
- const exitStatus = getStatechartExitStatus(instance, regionIndex, transition);
291
- if (exitStatus === StatechartTransitionStatus.ExitTimePending)
253
+ function getReadyTransitionIndex(instance, chart, regionIndex) {
254
+ const ri = regionIndex >>> 0;
255
+ const sourceStateIndex = instance.regionStates[ri];
256
+ const transitionCount = chart.regions[ri].states[sourceStateIndex >>> 0].transitions.length;
257
+ for (let transitionIndex = 0; transitionIndex < transitionCount; transitionIndex += 1) {
258
+ const transition = chart.regions[ri].states[sourceStateIndex >>> 0].transitions[transitionIndex];
259
+ const unmet = getFirstUnmetCondition(instance, chart, transition);
260
+ const exitStatus = getStatechartExitStatus(instance, ri, transition);
261
+ const target = transition.targetStateIndex;
262
+ if (unmet >= 0 || exitStatus === 'ExitTimePending') {
292
263
  continue;
293
- if (exitStatus === StatechartTransitionStatus.MissingRegionDuration) {
294
- instance.durationGuard?.(instance, {
295
- blend: 0,
264
+ }
265
+ if (exitStatus === 'MissingRegionDuration') {
266
+ const explanation = {
267
+ blend: 0.0,
296
268
  conditionIndex: -1,
297
- regionIndex,
298
- sourceStateIndex: instance.regionStates[regionIndex],
299
- status: StatechartTransitionStatus.MissingRegionDuration,
300
- targetStateIndex: transition.targetStateIndex,
301
- transitionIndex,
302
- });
269
+ regionIndex: regionIndex,
270
+ sourceStateIndex: sourceStateIndex,
271
+ status: 'MissingRegionDuration',
272
+ targetStateIndex: target,
273
+ transitionIndex: transitionIndex | 0,
274
+ };
275
+ const guard = instance.durationGuard;
276
+ if (guard !== null) {
277
+ const durationGuard = guard;
278
+ durationGuard(instance, explanation);
279
+ }
303
280
  }
304
- return transitionIndex;
281
+ return transitionIndex | 0;
305
282
  }
306
283
  return -1;
307
284
  }
308
285
  function getStatechartExitStatus(instance, regionIndex, transition) {
309
- if (transition.exitTimeRatio < 0)
310
- return StatechartTransitionStatus.Ready;
311
- const duration = instance.regionDuration[regionIndex];
312
- if (duration <= 0)
313
- return StatechartTransitionStatus.MissingRegionDuration;
314
- return instance.regionElapsed[regionIndex] / duration >= transition.exitTimeRatio
315
- ? StatechartTransitionStatus.Ready
316
- : StatechartTransitionStatus.ExitTimePending;
286
+ if (transition.exitTimeRatio < 0.0) {
287
+ return 'Ready';
288
+ }
289
+ const current = instance;
290
+ const duration = current.regionDuration[regionIndex];
291
+ if (duration <= 0.0) {
292
+ return 'MissingRegionDuration';
293
+ }
294
+ return current.regionElapsed[regionIndex] / duration >= transition.exitTimeRatio ? 'Ready' : 'ExitTimePending';
295
+ }
296
+ export function getStatechartRegionBlend(instance, regionIndex) {
297
+ const current = instance;
298
+ if (isStatechartInteger(regionIndex) && regionIndex >= 0 && regionIndex >>> 0 < current.regionBlend.length) {
299
+ return current.regionBlend[regionIndex >>> 0];
300
+ }
301
+ return -1.0;
302
+ }
303
+ export function getStatechartRegionState(instance, regionIndex) {
304
+ const current = instance;
305
+ if (isStatechartInteger(regionIndex) && regionIndex >= 0 && regionIndex >>> 0 < current.regionStates.length) {
306
+ return current.regionStates[regionIndex >>> 0];
307
+ }
308
+ return -1;
309
+ }
310
+ export function initializeStatechartInstancePortable(out, chart) {
311
+ validateStatechart(chart);
312
+ const chartInputCount = chart.inputs.length;
313
+ const chartRegionCount = chart.regions.length;
314
+ let inputValues = createStatechartFloat64Array(chartInputCount);
315
+ for (let inputIndex = 0; inputIndex < chartInputCount; inputIndex += 1) {
316
+ const chartGuard = chart;
317
+ const input = chartGuard.inputs[inputIndex];
318
+ inputValues[inputIndex] = input.kind === 'Boolean' ? (input.initialValue === 0.0 ? 0.0 : 1.0) : input.initialValue;
319
+ }
320
+ const regionCount = chartRegionCount;
321
+ let regionStates = createStatechartInt32Array(regionCount, 0);
322
+ for (let regionIndex = 0; regionIndex < regionCount; regionIndex += 1) {
323
+ regionStates[regionIndex] = chart.regions[regionIndex].initialStateIndex;
324
+ }
325
+ initializeStatechartInstanceFields(out, chart, inputValues, createStatechartFloat32Array(regionCount), createStatechartFloat64Array(regionCount), createStatechartFloat64Array(regionCount), regionStates, createStatechartInt32Array(regionCount, -1));
326
+ }
327
+ function getStatechartTransitionCount(chart, regionIndex, sourceStateIndex) {
328
+ const region = chart.regions[regionIndex >>> 0];
329
+ if (sourceStateIndex < 0 || sourceStateIndex >>> 0 >= region.states.length) {
330
+ throw new RangeError(`Statechart region ${regionIndex} has an invalid active state`);
331
+ }
332
+ return region.states[sourceStateIndex >>> 0].transitions.length;
317
333
  }
318
334
  function invalidRegionExplanation(regionIndex) {
319
335
  return {
320
- blend: -1,
336
+ blend: -1.0,
321
337
  conditionIndex: -1,
322
- regionIndex,
338
+ regionIndex: regionIndex,
323
339
  sourceStateIndex: -1,
324
- status: StatechartTransitionStatus.InvalidRegion,
340
+ status: 'InvalidRegion',
325
341
  targetStateIndex: -1,
326
342
  transitionIndex: -1,
327
343
  };
328
344
  }
345
+ export function setStatechartBooleanInput(instance, inputIndex, value) {
346
+ assertStatechartInputKind(instance, inputIndex, 'Boolean');
347
+ let current = instance;
348
+ current.inputValues[inputIndex >>> 0] = value ? 1.0 : 0.0;
349
+ }
350
+ export function setStatechartNumberInput(instance, inputIndex, value) {
351
+ assertStatechartInputKind(instance, inputIndex, 'Number');
352
+ let current = instance;
353
+ current.inputValues[inputIndex >>> 0] = value;
354
+ }
355
+ export function setStatechartRegionDuration(instance, regionIndex, duration) {
356
+ const len = instance.regionDuration.length;
357
+ if (!isStatechartInteger(regionIndex) || regionIndex < 0 || regionIndex >>> 0 >= len) {
358
+ throw new RangeError(`Statechart region index ${regionIndex} is out of range`);
359
+ }
360
+ if (!Number.isFinite(duration) || duration < 0.0) {
361
+ throw new RangeError('Statechart region duration must be finite and non-negative');
362
+ }
363
+ instance.regionDuration[regionIndex >>> 0] = duration;
364
+ }
329
365
  function validateStatechart(chart) {
330
- for (let inputIndex = 0; inputIndex < chart.inputs.length; inputIndex++) {
366
+ for (let inputIndex = 0; inputIndex < chart.inputs.length; inputIndex += 1) {
331
367
  const kind = chart.inputs[inputIndex].kind;
332
- if (kind !== StatechartInputKind.Boolean &&
333
- kind !== StatechartInputKind.Number &&
334
- kind !== StatechartInputKind.Trigger) {
335
- throw new TypeError(`Statechart input ${inputIndex} has unknown kind ${String(kind)}`);
368
+ if (kind !== 'Boolean' && kind !== 'Number' && kind !== 'Trigger') {
369
+ throwStatechartUnknownInputKindTypeError(inputIndex, kind);
336
370
  }
337
371
  }
338
- for (let regionIndex = 0; regionIndex < chart.regions.length; regionIndex++) {
372
+ for (let regionIndex = 0; regionIndex < chart.regions.length; regionIndex += 1) {
339
373
  const region = chart.regions[regionIndex];
340
- if (region.initialStateIndex < 0 || region.initialStateIndex >= region.states.length) {
374
+ if (!isStatechartInteger(region.initialStateIndex) ||
375
+ region.initialStateIndex < 0 ||
376
+ region.initialStateIndex >>> 0 >= region.states.length) {
341
377
  throw new RangeError(`Statechart region ${regionIndex} has an invalid initialStateIndex`);
342
378
  }
343
- for (let stateIndex = 0; stateIndex < region.states.length; stateIndex++) {
379
+ for (let stateIndex = 0; stateIndex < region.states.length; stateIndex += 1) {
344
380
  const state = region.states[stateIndex];
345
- if (typeof state.kind !== 'string' || state.kind.length === 0) {
346
- throw new TypeError(`Statechart region ${regionIndex} state ${stateIndex} has an invalid kind`);
381
+ if (!isStatechartString(state.kind) || state.kind.length === 0) {
382
+ throwStatechartTypeError(`Statechart region ${regionIndex} state ${stateIndex} has an invalid kind`);
347
383
  }
348
- for (let transitionIndex = 0; transitionIndex < state.transitions.length; transitionIndex++) {
384
+ for (let transitionIndex = 0; transitionIndex < state.transitions.length; transitionIndex += 1) {
349
385
  const transition = state.transitions[transitionIndex];
350
- if (!Number.isFinite(transition.durationMs) || transition.durationMs < 0) {
386
+ if (!Number.isFinite(transition.durationMs) || transition.durationMs < 0.0) {
351
387
  throw new RangeError(`Statechart region ${regionIndex} state ${stateIndex} transition ${transitionIndex} has an invalid duration`);
352
388
  }
353
- if (!Number.isFinite(transition.exitTimeRatio) || transition.exitTimeRatio < -1) {
389
+ if (!Number.isFinite(transition.exitTimeRatio) || transition.exitTimeRatio < -1.0) {
354
390
  throw new RangeError(`Statechart region ${regionIndex} state ${stateIndex} transition ${transitionIndex} has an invalid exit time`);
355
391
  }
356
- if (transition.targetStateIndex < 0 || transition.targetStateIndex >= region.states.length) {
392
+ if (!isStatechartInteger(transition.targetStateIndex) ||
393
+ transition.targetStateIndex < 0 ||
394
+ transition.targetStateIndex >>> 0 >= region.states.length) {
357
395
  throw new RangeError(`Statechart region ${regionIndex} state ${stateIndex} transition ${transitionIndex} has an invalid target`);
358
396
  }
359
- for (let conditionIndex = 0; conditionIndex < transition.conditions.length; conditionIndex++) {
397
+ for (let conditionIndex = 0; conditionIndex < transition.conditions.length; conditionIndex += 1) {
360
398
  const condition = transition.conditions[conditionIndex];
361
- const inputIndex = condition.inputIndex;
362
- if (!Number.isInteger(inputIndex) || inputIndex < 0 || inputIndex >= chart.inputs.length) {
399
+ if (!isStatechartInteger(condition.inputIndex) ||
400
+ condition.inputIndex < 0 ||
401
+ condition.inputIndex >>> 0 >= chart.inputs.length) {
363
402
  throw new RangeError(`Statechart region ${regionIndex} state ${stateIndex} transition ${transitionIndex} has an invalid input`);
364
403
  }
365
- if (!Object.values(StatechartComparison).includes(condition.comparison)) {
366
- throw new TypeError(`Statechart region ${regionIndex} state ${stateIndex} transition ${transitionIndex} has an invalid comparison`);
404
+ if (!isStatechartComparison(condition.comparison)) {
405
+ throwStatechartTypeError(`Statechart region ${regionIndex} state ${stateIndex} transition ${transitionIndex} has an invalid comparison`);
367
406
  }
368
407
  }
369
408
  }