@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.
- package/README.md +2 -2
- package/dist/.tsbuildinfo.contract +1 -0
- package/dist/.tsbuildinfo.runtime +1 -0
- package/dist/contract.d.ts +7 -4
- package/dist/contract.d.ts.map +1 -1
- package/dist/contract.js +8 -4
- package/dist/contract.js.map +1 -1
- package/dist/contract.statechart-types.d.ts +3 -0
- package/dist/contract.statechart-types.d.ts.map +1 -0
- package/dist/contract.statechart-types.js +4 -0
- package/dist/contract.statechart-types.js.map +1 -0
- package/dist/enableStatechartGuards.d.ts +5 -4
- package/dist/enableStatechartGuards.d.ts.map +1 -1
- package/dist/enableStatechartGuards.js +11 -4
- package/dist/enableStatechartGuards.js.map +1 -1
- package/dist/index.d.ts +3 -3
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +4 -3
- package/dist/index.js.map +1 -1
- package/dist/statechart.d.ts +13 -12
- package/dist/statechart.d.ts.map +1 -1
- package/dist/statechart.js +302 -263
- package/dist/statechart.js.map +1 -1
- package/dist/statechartCompat.d.ts +46 -0
- package/dist/statechartCompat.d.ts.map +1 -0
- package/dist/statechartCompat.js +127 -0
- package/dist/statechartCompat.js.map +1 -0
- package/dist/statechartInstanceFields.d.ts +3 -0
- package/dist/statechartInstanceFields.d.ts.map +1 -0
- package/dist/statechartInstanceFields.js +13 -0
- package/dist/statechartInstanceFields.js.map +1 -0
- package/dist/statechartInstanceInit.d.ts +4 -0
- package/dist/statechartInstanceInit.d.ts.map +1 -0
- package/dist/statechartInstanceInit.js +7 -0
- package/dist/statechartInstanceInit.js.map +1 -0
- package/dist/statechartRuntime.d.ts +9 -0
- package/dist/statechartRuntime.d.ts.map +1 -0
- package/dist/statechartRuntime.js +25 -0
- package/dist/statechartRuntime.js.map +1 -0
- package/dist/statechartSignalEmit.d.ts +3 -0
- package/dist/statechartSignalEmit.d.ts.map +1 -0
- package/dist/statechartSignalEmit.js +7 -0
- package/dist/statechartSignalEmit.js.map +1 -0
- package/dist/statechartSignals.d.ts +4 -3
- package/dist/statechartSignals.d.ts.map +1 -1
- package/dist/statechartSignals.js +2 -2
- package/dist/statechartSignals.js.map +1 -1
- package/dist/statechartTypedArrays.d.ts +4 -0
- package/dist/statechartTypedArrays.d.ts.map +1 -0
- package/dist/statechartTypedArrays.js +10 -0
- package/dist/statechartTypedArrays.js.map +1 -0
- package/dist/types.d.ts +85 -0
- package/dist/types.d.ts.map +1 -0
- package/dist/types.js +33 -0
- package/dist/types.js.map +1 -0
- package/package.json +7 -6
- package/src/enableStatechartGuards.test.ts +26 -17
- package/src/statechart.test.ts +434 -291
- package/src/statechartCompat.test.ts +165 -0
- package/src/statechartInstanceFields.test.ts +36 -0
- package/src/statechartInstanceInit.test.ts +20 -0
- package/src/statechartIntegerDomain.test.ts +57 -0
- package/src/statechartRuntime.test.ts +55 -0
- package/src/statechartSignalEmit.test.ts +19 -0
- package/src/statechartSignals.test.ts +9 -9
- package/src/statechartTypedArrays.test.ts +25 -0
package/dist/statechart.js
CHANGED
|
@@ -1,369 +1,408 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
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
|
-
|
|
10
|
-
|
|
11
|
-
|
|
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
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
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
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
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
|
|
44
|
+
return changedCount;
|
|
32
45
|
}
|
|
33
46
|
export function createStatechartInstance(chart) {
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
return
|
|
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
|
-
|
|
43
|
-
|
|
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
|
-
|
|
46
|
-
const
|
|
47
|
-
|
|
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
|
-
|
|
64
|
+
}
|
|
65
|
+
const state = region.states[sourceStateIndex >>> 0];
|
|
66
|
+
const activeTransitionIndex = instance.regionTransitions[ri];
|
|
50
67
|
if (activeTransitionIndex >= 0) {
|
|
51
|
-
|
|
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[
|
|
73
|
+
blend: instance.regionBlend[ri],
|
|
56
74
|
conditionIndex: -1,
|
|
57
|
-
regionIndex,
|
|
58
|
-
sourceStateIndex,
|
|
59
|
-
status:
|
|
60
|
-
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:
|
|
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
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
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,
|
|
92
|
-
if (exitStatus ===
|
|
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:
|
|
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 ===
|
|
104
|
-
firstBlocked
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
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:
|
|
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
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
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
|
-
|
|
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
|
-
|
|
225
|
-
|
|
226
|
-
|
|
164
|
+
}
|
|
165
|
+
let current = instance;
|
|
166
|
+
current.regionTransitions[ri] = transitionIndex;
|
|
167
|
+
current.regionBlend[ri] = 0.0;
|
|
227
168
|
}
|
|
228
|
-
|
|
229
|
-
const
|
|
230
|
-
|
|
231
|
-
|
|
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
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
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
|
|
242
|
-
|
|
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
|
-
|
|
245
|
-
|
|
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
|
-
|
|
250
|
-
|
|
251
|
-
|
|
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
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
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
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
const
|
|
277
|
-
const
|
|
278
|
-
|
|
279
|
-
|
|
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
|
|
285
|
-
const
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
const exitStatus = getStatechartExitStatus(instance,
|
|
291
|
-
|
|
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
|
-
|
|
294
|
-
|
|
295
|
-
|
|
264
|
+
}
|
|
265
|
+
if (exitStatus === 'MissingRegionDuration') {
|
|
266
|
+
const explanation = {
|
|
267
|
+
blend: 0.0,
|
|
296
268
|
conditionIndex: -1,
|
|
297
|
-
regionIndex,
|
|
298
|
-
sourceStateIndex:
|
|
299
|
-
status:
|
|
300
|
-
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
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
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:
|
|
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 !==
|
|
333
|
-
kind
|
|
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
|
|
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 (
|
|
346
|
-
|
|
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
|
|
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
|
-
|
|
362
|
-
|
|
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 (!
|
|
366
|
-
|
|
404
|
+
if (!isStatechartComparison(condition.comparison)) {
|
|
405
|
+
throwStatechartTypeError(`Statechart region ${regionIndex} state ${stateIndex} transition ${transitionIndex} has an invalid comparison`);
|
|
367
406
|
}
|
|
368
407
|
}
|
|
369
408
|
}
|