@ue-too/being 0.14.1 → 0.16.0

package/index.js

@@ -1,5 +1,366 @@
-var w=()=>{};class W{_currentState;_states;_context;_statesArray;_stateChangeCallbacks;_happensCallbacks;_timeouts=void 0;_initialState;constructor(j,z,B,q=!0){if(this._states=j,this._currentState="INITIAL",this._initialState=z,this._context=B,this._statesArray=Object.keys(j),this._stateChangeCallbacks=[],this._happensCallbacks=[],q)this.start()}reset(){this.wrapup(),this.switchTo("INITIAL"),this.start()}start(){if(this.currentState!=="INITIAL")return;this._context.setup(),this.switchTo(this._initialState),this._states[this._initialState].uponEnter(this._context,this,this._initialState)}wrapup(){if(this._currentState==="TERMINAL")return;let j=this._currentState;if(j!=="INITIAL")this._states[j].beforeExit(this._context,this,"TERMINAL");this._context.cleanup(),this.switchTo("TERMINAL")}switchTo(j){this._currentState=j}happens(...j){if(this._timeouts)clearTimeout(this._timeouts);if(this._currentState==="INITIAL"||this._currentState==="TERMINAL")return{handled:!1};this._happensCallbacks.forEach((B)=>B(j,this._context));let z=this._states[this._currentState].handles(j,this._context,this);if(z.handled&&z.nextState!==void 0&&z.nextState!==this._currentState){let B=this._currentState;this._states[this._currentState].beforeExit(this._context,this,z.nextState),this.switchTo(z.nextState),this._states[this._currentState].uponEnter(this._context,this,B);for(let q of this._stateChangeCallbacks)q(B,this._currentState)}return z}onStateChange(j){this._stateChangeCallbacks.push(j)}onHappens(j){this._happensCallbacks.push(j)}get currentState(){return this._currentState}setContext(j){this._context=j}get possibleStates(){return this._statesArray}get states(){return this._states}}class H{_eventReactions={};_guards={};_eventGuards={};_delay=void 0;get handlingEvents(){return Object.keys(this._eventReactions)}get guards(){return this._guards}get eventGuards(){return this._eventGuards}get delay(){return this._delay}uponEnter(j,z,B){}beforeExit(j,z,B){}handles(j,z,B){let q=j[0],J=j[1];if(this._eventReactions[q]){let V=this._eventReactions[q].action(z,J,B),Z=this._eventReactions[q].defaultTargetState,U=this._eventGuards[q],$={handled:!0,nextState:Z},Q=V!==void 0?{...$,output:V}:$;if(U){let X=U.find((Y)=>{if(this._guards[Y.guard])return this._guards[Y.guard](z);return!1});return X?{...Q,nextState:X.target}:Q}return Q}return{handled:!1}}}function P(j){return(z)=>j.includes(z)}function C(j){return j}function I(j,z){if(!j.states.includes(j.initialState))throw Error(`Initial state "${j.initialState}" must be in the states array`);for(let q of j.stateDefinitions){if(!j.states.includes(q.name))throw Error(`State definition "${q.name}" is not in the states array`);for(let J of q.transitions){let V=j.events;if(!(String(J.event)in V))throw Error(`Event "${String(J.event)}" in state "${q.name}" is not defined in events`);if(!j.states.includes(J.targetState))throw Error(`Target state "${J.targetState}" in transition from "${q.name}" is not in the states array`);if(J.guards)for(let Z of J.guards){if(!j.states.includes(Z.targetState))throw Error(`Guard target state "${Z.targetState}" is not in the states array`);if(typeof Z.guard==="string"){if(!q.guards||!(Z.guard in q.guards))throw Error(`Guard "${Z.guard}" referenced in state "${q.name}" for event "${String(J.event)}" is not defined in the state's guards section`)}}}}let B={};for(let q of j.stateDefinitions){let J={},V={},Z={};if(q.guards)for(let[Q,X]of Object.entries(q.guards))V[Q]=X;for(let Q of q.transitions){let X=Q.event;if(J[X]={action:Q.action||w,defaultTargetState:Q.targetState},Q.guards&&Q.guards.length>0){let F=[];Q.guards.forEach((Y,G)=>{let L;if(typeof Y.guard==="string"){if(L=Y.guard,!V[L])throw Error(`Guard "${L}" referenced in state "${q.name}" for event "${String(X)}" is not defined in the state's guards section`)}else L=`guard_${q.name}_${String(X)}_${G}`,V[L]=Y.guard;F.push({guard:L,target:Y.targetState})}),Z[X]=F}}class U extends H{eventReactions=J;_guards=V;_eventGuards=Z}let $=new U;if(q.onEnter){let Q=$.uponEnter.bind($);$.uponEnter=(X,F,Y)=>{Q(X,F,Y),q.onEnter(X,Y)}}if(q.onExit){let Q=$.beforeExit.bind($);$.beforeExit=(X,F,Y)=>{Q(X,F,Y),q.onExit(X,Y)}}B[q.name]=$}for(let q of j.states)if(!B[q]){class J extends H{eventReactions={}}B[q]=new J}return new W(B,j.initialState,z,!0)}class _ extends H{_childStateMachineConfig=null;_historyState=null;_context=null;getCurrentChildState(){if(!this._childStateMachineConfig)return null;let z=this._childStateMachineConfig.stateMachine.currentState;return z==="INITIAL"||z==="TERMINAL"?null:z}getStatePath(j){let z=this.getCurrentChildState();if(z===null)return j;return`${j}.${z}`}uponEnter(j,z,B){super.uponEnter(j,z,B),this._context=j;let q=this.getChildStateMachine();this._childStateMachineConfig=q;let J=q.rememberHistory&&this._historyState?this._historyState:q.defaultChildState,V=q.stateMachine;if(V.currentState==="INITIAL")V.start();V.switchTo(J),V.states[J].uponEnter(j,V,"INITIAL")}beforeExit(j,z,B){if(this._childStateMachineConfig?.rememberHistory){let q=this.getCurrentChildState();if(q!==null)this._historyState=q}if(this._childStateMachineConfig){let q=this.getCurrentChildState();if(q!==null)this._childStateMachineConfig.stateMachine.states[q].beforeExit(j,this._childStateMachineConfig.stateMachine,"TERMINAL");this._childStateMachineConfig.stateMachine.wrapup()}super.beforeExit(j,z,B)}handles(j,z,B){if(this._childStateMachineConfig){if(this._childStateMachineConfig.stateMachine.happens(...j).handled)return{handled:!0}}return super.handles(j,z,B)}}class O extends W{getCurrentStatePath(){let j=this.currentState;if(j==="INITIAL"||j==="TERMINAL")return j;let z=this.states[j];if(z instanceof _)return z.getStatePath(j);return j}getActiveStatePath(){let j=this.currentState;if(j==="INITIAL"||j==="TERMINAL")return[j];let z=[j],B=this.states[j];if(B instanceof _){let q=B.getCurrentChildState();if(q!==null)z.push(q)}return z}isInStatePath(j){let z=this.getCurrentStatePath();return z===j||z.startsWith(j+".")}}export{C as createStateMachineSchemaWithInferredStates,I as createStateMachineFromSchema,P as createStateGuard,W as TemplateStateMachine,H as TemplateState,w as NO_OP,O as HierarchicalStateMachine,_ as CompositeState};
+// src/interface.ts
+var NO_OP = () => {};
 
-//# debugId=A4A1425C023A074164756E2164756E21
+class TemplateStateMachine {
+  _currentState;
+  _states;
+  _context;
+  _statesArray;
+  _stateChangeCallbacks;
+  _happensCallbacks;
+  _timeouts = undefined;
+  _initialState;
+  constructor(states, initialState, context, autoStart = true) {
+    this._states = states;
+    this._currentState = "INITIAL";
+    this._initialState = initialState;
+    this._context = context;
+    this._statesArray = Object.keys(states);
+    this._stateChangeCallbacks = [];
+    this._happensCallbacks = [];
+    if (autoStart) {
+      this.start();
+    }
+  }
+  reset() {
+    this.wrapup();
+    this.switchTo("INITIAL");
+    this.start();
+  }
+  start() {
+    if (this.currentState !== "INITIAL") {
+      return;
+    }
+    this._context.setup();
+    this.switchTo(this._initialState);
+    this._states[this._initialState].uponEnter(this._context, this, this._initialState);
+  }
+  wrapup() {
+    if (this._currentState === "TERMINAL") {
+      return;
+    }
+    const originalState = this._currentState;
+    if (originalState !== "INITIAL") {
+      this._states[originalState].beforeExit(this._context, this, "TERMINAL");
+    }
+    this._context.cleanup();
+    this.switchTo("TERMINAL");
+  }
+  switchTo(state) {
+    this._currentState = state;
+  }
+  happens(...args) {
+    if (this._timeouts) {
+      clearTimeout(this._timeouts);
+    }
+    if (this._currentState === "INITIAL" || this._currentState === "TERMINAL") {
+      return { handled: false };
+    }
+    this._happensCallbacks.forEach((callback) => callback(args, this._context));
+    const result = this._states[this._currentState].handles(args, this._context, this);
+    if (result.handled && result.nextState !== undefined && result.nextState !== this._currentState) {
+      const originalState = this._currentState;
+      this._states[this._currentState].beforeExit(this._context, this, result.nextState);
+      this.switchTo(result.nextState);
+      this._states[this._currentState].uponEnter(this._context, this, originalState);
+      for (const callback of this._stateChangeCallbacks) {
+        callback(originalState, this._currentState);
+      }
+    }
+    return result;
+  }
+  onStateChange(callback) {
+    this._stateChangeCallbacks.push(callback);
+  }
+  onHappens(callback) {
+    this._happensCallbacks.push(callback);
+  }
+  get currentState() {
+    return this._currentState;
+  }
+  setContext(context) {
+    this._context = context;
+  }
+  get possibleStates() {
+    return this._statesArray;
+  }
+  get states() {
+    return this._states;
+  }
+}
+
+class TemplateState {
+  _eventReactions = {};
+  _guards = {};
+  _eventGuards = {};
+  _delay = undefined;
+  _defer = undefined;
+  get handlingEvents() {
+    return Object.keys(this._eventReactions);
+  }
+  get guards() {
+    return this._guards;
+  }
+  get eventGuards() {
+    return this._eventGuards;
+  }
+  get eventReactions() {
+    return this._eventReactions;
+  }
+  get delay() {
+    return this._delay;
+  }
+  uponEnter(context, stateMachine, from) {}
+  beforeExit(context, stateMachine, to) {}
+  handles(args, context, stateMachine) {
+    const eventKey = args[0];
+    const eventPayload = args[1];
+    if (this._defer) {
+      const result = this._defer.action(context, eventPayload, eventKey, stateMachine);
+      if (result.handled) {
+        return result;
+      }
+    }
+    if (this._eventReactions[eventKey]) {
+      const output = this._eventReactions[eventKey].action(context, eventPayload, stateMachine);
+      const targetState = this._eventReactions[eventKey].defaultTargetState;
+      const guardsToEvaluate = this._eventGuards[eventKey];
+      const baseResult = {
+        handled: true,
+        nextState: targetState
+      };
+      const resultWithOutput = output !== undefined ? { ...baseResult, output } : baseResult;
+      if (guardsToEvaluate) {
+        const target = guardsToEvaluate.find((guard) => {
+          if (this._guards[guard.guard]) {
+            return this._guards[guard.guard](context);
+          }
+          return false;
+        });
+        const finalResult = target ? { ...resultWithOutput, nextState: target.target } : resultWithOutput;
+        return finalResult;
+      }
+      return resultWithOutput;
+    }
+    return { handled: false };
+  }
+}
+function createStateGuard(set) {
+  return (s) => set.includes(s);
+}
+// src/schema-factory.ts
+function createStateMachineSchemaWithInferredStates(schema) {
+  return schema;
+}
+function createStateMachineFromSchema(schema, context) {
+  if (!schema.states.includes(schema.initialState)) {
+    throw new Error(`Initial state "${schema.initialState}" must be in the states array`);
+  }
+  for (const stateDef of schema.stateDefinitions) {
+    if (!schema.states.includes(stateDef.name)) {
+      throw new Error(`State definition "${stateDef.name}" is not in the states array`);
+    }
+    for (const transition of stateDef.transitions) {
+      const eventsRecord = schema.events;
+      if (!(String(transition.event) in eventsRecord)) {
+        throw new Error(`Event "${String(transition.event)}" in state "${stateDef.name}" is not defined in events`);
+      }
+      if (!schema.states.includes(transition.targetState)) {
+        throw new Error(`Target state "${transition.targetState}" in transition from "${stateDef.name}" is not in the states array`);
+      }
+      if (transition.guards) {
+        for (const guard of transition.guards) {
+          if (!schema.states.includes(guard.targetState)) {
+            throw new Error(`Guard target state "${guard.targetState}" is not in the states array`);
+          }
+          if (typeof guard.guard === "string") {
+            if (!stateDef.guards || !(guard.guard in stateDef.guards)) {
+              throw new Error(`Guard "${guard.guard}" referenced in state "${stateDef.name}" for event "${String(transition.event)}" is not defined in the state's guards section`);
+            }
+          }
+        }
+      }
+    }
+  }
+  const stateInstances = {};
+  for (const stateDef of schema.stateDefinitions) {
+    const eventReactions = {};
+    const allGuards = {};
+    const eventGuards = {};
+    if (stateDef.guards) {
+      for (const [guardName, guardFunction] of Object.entries(stateDef.guards)) {
+        allGuards[guardName] = guardFunction;
+      }
+    }
+    for (const transition of stateDef.transitions) {
+      const eventName = transition.event;
+      eventReactions[eventName] = {
+        action: transition.action || NO_OP,
+        defaultTargetState: transition.targetState
+      };
+      if (transition.guards && transition.guards.length > 0) {
+        const guardMappings = [];
+        transition.guards.forEach((guardDef, index) => {
+          let guardKey;
+          if (typeof guardDef.guard === "string") {
+            guardKey = guardDef.guard;
+            if (!allGuards[guardKey]) {
+              throw new Error(`Guard "${guardKey}" referenced in state "${stateDef.name}" for event "${String(eventName)}" is not defined in the state's guards section`);
+            }
+          } else {
+            guardKey = `guard_${stateDef.name}_${String(eventName)}_${index}`;
+            allGuards[guardKey] = guardDef.guard;
+          }
+          guardMappings.push({
+            guard: guardKey,
+            target: guardDef.targetState
+          });
+        });
+        eventGuards[eventName] = guardMappings;
+      }
+    }
+
+    class DynamicState extends TemplateState {
+      _eventReactions = eventReactions;
+      _guards = allGuards;
+      _eventGuards = eventGuards;
+    }
+    const stateInstance = new DynamicState;
+    if (stateDef.onEnter) {
+      const originalOnEnter = stateInstance.uponEnter.bind(stateInstance);
+      stateInstance.uponEnter = (ctx, sm, from) => {
+        originalOnEnter(ctx, sm, from);
+        stateDef.onEnter(ctx, from);
+      };
+    }
+    if (stateDef.onExit) {
+      const originalOnExit = stateInstance.beforeExit.bind(stateInstance);
+      stateInstance.beforeExit = (ctx, sm, to) => {
+        originalOnExit(ctx, sm, to);
+        stateDef.onExit(ctx, to);
+      };
+    }
+    stateInstances[stateDef.name] = stateInstance;
+  }
+  for (const stateName of schema.states) {
+    if (!stateInstances[stateName]) {
+
+      class EmptyState extends TemplateState {
+        _eventReactions = {};
+      }
+      stateInstances[stateName] = new EmptyState;
+    }
+  }
+  return new TemplateStateMachine(stateInstances, schema.initialState, context, true);
+}
+// src/hierarchical.ts
+class CompositeState extends TemplateState {
+  _childStateMachineConfig = null;
+  _historyState = null;
+  _context = null;
+  getCurrentChildState() {
+    if (!this._childStateMachineConfig) {
+      return null;
+    }
+    const stateMachine = this._childStateMachineConfig.stateMachine;
+    const current = stateMachine.currentState;
+    return current === "INITIAL" || current === "TERMINAL" ? null : current;
+  }
+  getStatePath(parentState) {
+    const childState = this.getCurrentChildState();
+    if (childState === null) {
+      return parentState;
+    }
+    return `${parentState}.${childState}`;
+  }
+  uponEnter(context, stateMachine, from) {
+    super.uponEnter(context, stateMachine, from);
+    this._context = context;
+    const config = this.getChildStateMachine();
+    this._childStateMachineConfig = config;
+    const childStateToEnter = config.rememberHistory && this._historyState ? this._historyState : config.defaultChildState;
+    const childMachine = config.stateMachine;
+    if (childMachine.currentState === "INITIAL") {
+      childMachine.start();
+    }
+    childMachine.switchTo(childStateToEnter);
+    const childState = childMachine.states[childStateToEnter];
+    childState.uponEnter(context, childMachine, "INITIAL");
+  }
+  beforeExit(context, stateMachine, to) {
+    if (this._childStateMachineConfig?.rememberHistory) {
+      const currentChild = this.getCurrentChildState();
+      if (currentChild !== null) {
+        this._historyState = currentChild;
+      }
+    }
+    if (this._childStateMachineConfig) {
+      const currentChild = this.getCurrentChildState();
+      if (currentChild !== null) {
+        const childState = this._childStateMachineConfig.stateMachine.states[currentChild];
+        childState.beforeExit(context, this._childStateMachineConfig.stateMachine, "TERMINAL");
+      }
+      this._childStateMachineConfig.stateMachine.wrapup();
+    }
+    super.beforeExit(context, stateMachine, to);
+  }
+  handles(args, context, stateMachine) {
+    if (this._childStateMachineConfig) {
+      const childMachine = this._childStateMachineConfig.stateMachine;
+      const childResult = childMachine.happens(...args);
+      if (childResult.handled) {
+        return {
+          handled: true
+        };
+      }
+    }
+    return super.handles(args, context, stateMachine);
+  }
+}
+
+class HierarchicalStateMachine extends TemplateStateMachine {
+  getCurrentStatePath() {
+    const currentState = this.currentState;
+    if (currentState === "INITIAL" || currentState === "TERMINAL") {
+      return currentState;
+    }
+    const state = this.states[currentState];
+    if (state instanceof CompositeState) {
+      return state.getStatePath(currentState);
+    }
+    return currentState;
+  }
+  getActiveStatePath() {
+    const currentState = this.currentState;
+    if (currentState === "INITIAL" || currentState === "TERMINAL") {
+      return [currentState];
+    }
+    const path = [currentState];
+    const state = this.states[currentState];
+    if (state instanceof CompositeState) {
+      const childState = state.getCurrentChildState();
+      if (childState !== null) {
+        path.push(childState);
+      }
+    }
+    return path;
+  }
+  isInStatePath(path) {
+    const currentPath = this.getCurrentStatePath();
+    return currentPath === path || currentPath.startsWith(path + ".");
+  }
+}
+export {
+  createStateMachineSchemaWithInferredStates,
+  createStateMachineFromSchema,
+  createStateGuard,
+  TemplateStateMachine,
+  TemplateState,
+  NO_OP,
+  HierarchicalStateMachine,
+  CompositeState
+};
+
+//# debugId=4D129717DB00D55B64756E2164756E21
 
 //# sourceMappingURL=index.js.map