diff --git a/dist/index.d.ts b/dist/index.d.ts index 40d9a09..894c7d8 100644 --- a/dist/index.d.ts +++ b/dist/index.d.ts @@ -53,8 +53,8 @@ export interface Interpreter_T { isTransitioning: boolean; isPaused: boolean; start: () => Interpreter_T; - Peer: (name: string, peer: Interpreter_T) => Interpreter_T; - Peers: (name: string, peers: Array>) => Interpreter_T; + Peer: (name: string, peer: Interpreter_T) => Interpreter_T; + Peers: (name: string, peers: Array>) => Interpreter_T; } /** * Description placeholder diff --git a/dist/index.js b/dist/index.js index 618d0f5..e6aaa3e 100644 --- a/dist/index.js +++ b/dist/index.js @@ -1,2 +1,2 @@ -var v=function(...t){return{states:t}},A=function(t,...e){return{name:t,eventReactionCouplings:e}},h=function(t,...e){return{eventName:t,reactions:e}},F=function(t){return{type:"SideEffect",fn:t}},k=function(t){return{type:"Goto",targetStateName:t}},M=function(t){return{type:"ContextMutation",fn:t}},w=function(t,e){return{type:"SetPeer",name:t,peerCreationFunction:e}},R=function(t,e){return{type:"SetPeers",name:t,peerCreationFunction:e}},G=function(t,e){return{type:"AddPeers",name:t,peerCreationFunction:e}};function O(t,e,o){typeof o>"u"&&(o=t.states[0].name);let n={machine:t,state:o,context:e,eventQueue:[],isTransitioning:!1,peers:{},peerSubscriptionIds:new Map,subscriptionsToEvents:{},subscriptionsToState:{},subscriptionsToSettledState:{},isPaused:!0};return n.start=()=>(l(n),n),n.Peer=(i,r)=>(f(n,i,r),n),n.Peers=(i,r)=>(S(n,i,r),n),c(n,["entry",null]),n}function l(t){t.isPaused===!0&&(t.isPaused=!1,T(t))}function m(t){t.isPaused===!1&&(t.isPaused=!0)}function P(t){return t.machine.states.find(e=>e.name===t.state)}function g(t,e){return t.eventReactionCouplings.filter(o=>o.eventName===e[0])}function c(t,e){t.eventQueue.push(e),t.isTransitioning===!1&&T(t)}var Q=c;function T(t){for(t.isTransitioning=!0;t.eventQueue.length>0&&t.isPaused===!1;)y(t);t.isTransitioning=!1,Object.values(t.subscriptionsToSettledState).forEach(e=>{e(t)})}function y(t){let e=t.eventQueue.shift();if(typeof e<"u"){let o=P(t),i=g(o,e).map(s=>s.reactions).flat(),{sideEffects:r,contextMutations:u,peerings:x,goto_:p}=b(i),d=t.context;u.forEach(s=>{t.context=s.fn(t.context,e,t)}),p!==null&&(c(t,["exit",null]),t.state=p.targetStateName,Object.values(t.subscriptionsToState).forEach(s=>{s(e,t)}),c(t,["entry",null])),x.forEach(s=>{s.type==="SetPeer"?f(t,s.name,s.peerCreationFunction(t.context,e,t)):s.type==="SetPeers"?S(t,s.name,s.peerCreationFunction(t.context,e,t)):s.type==="AddPeers"&&E(t,s.name,s.peerCreationFunction(t.context,e,t))}),Object.values(t.subscriptionsToEvents).forEach(s=>{s(e,t)}),r.forEach(s=>{s.fn(t.context,e,t,d)})}}function b(t){let e=[],o=[],n=[],i=null;return t.forEach(r=>{r.type==="SideEffect"?e.push(r):r.type==="ContextMutation"?o.push(r):r.type==="SetPeer"?n.push(r):r.type==="Goto"&&(i=r)}),{sideEffects:e,contextMutations:o,peerings:n,goto_:i}}var a=0;function I(t,e){return a++,t.subscriptionsToSettledState[a.toString()]=e,a.toString()}var j=I;function N(t,e){return a++,t.subscriptionsToState[a.toString()]=e,a.toString()}function C(t,e){return a++,t.subscriptionsToEvents[a.toString()]=e,a.toString()}function _(t,e){delete t.subscriptionsToSettledState[e.toString()],delete t.subscriptionsToState[e.toString()],delete t.subscriptionsToEvents[e.toString()]}function f(t,e,o){t.peers.hasOwnProperty(e)&&_(t,t.peerSubscriptionIds.get(t.peers[e])),t.peers[e]=o;let n=C(o,(i,r)=>{t.isTransitioning===!1&&c(t,[e+"."+i[0],i[1]])});t.peerSubscriptionIds.set(o,n)}function S(t,e,o){t.peers.hasOwnProperty(e)&&t.peers[e].forEach(n=>{_(t,t.peerSubscriptionIds.get(n))}),t.peers[e]=o,o.forEach(n=>{let i=C(n,(r,u)=>{t.isTransitioning===!1&&c(t,[e+"."+r[0],r[1]])});t.peerSubscriptionIds.set(n,i)})}function E(t,e,o){t.peers.hasOwnProperty(e)||(t.peers[e]=[]),t.peers[e].concat(o),o.forEach(n=>{let i=C(n,(r,u)=>{t.isTransitioning===!1&&c(t,[e+"."+r[0],r[1]])});t.peerSubscriptionIds.set(n,i)})}export{G as AddPeers,M as Context,k as Goto,O as Interpreter,v as Machine,h as On,w as Peer,R as Peers,F as SideEffect,A as State,E as addPeers,Q as enqueue,m as pause,c as send,f as setPeer,S as setPeers,l as start,I as subscribe,C as subscribeToEvents,j as subscribeToSettledState,N as subscribeToState,_ as unsubscribe}; +var v=function(...t){return{states:t}},A=function(t,...e){return{name:t,eventReactionCouplings:e}},h=function(t,...e){return{eventName:t,reactions:e}},F=function(t){return{type:"SideEffect",fn:t}},M=function(t){return{type:"Goto",targetStateName:t}},k=function(t){return{type:"ContextMutation",fn:t}},R=function(t,e){return{type:"SetPeer",name:t,peerCreationFunction:e}},w=function(t,e){return{type:"SetPeers",name:t,peerCreationFunction:e}},G=function(t,e){return{type:"AddPeers",name:t,peerCreationFunction:e}};function O(t,e,o){typeof o>"u"&&(o=t.states[0].name);let n={machine:t,state:o,context:e,eventQueue:[],isTransitioning:!1,peers:{},peerSubscriptionIds:new Map,subscriptionsToEvents:{},subscriptionsToState:{},subscriptionsToSettledState:{},isPaused:!0};return n.start=()=>(l(n),n),n.Peer=(i,r)=>(f(n,i,r),n),n.Peers=(i,r)=>(S(n,i,r),n),c(n,["entry",null]),n}function l(t){t.isPaused===!0&&(t.isPaused=!1,T(t))}function m(t){t.isPaused===!1&&(t.isPaused=!0)}function P(t){return t.machine.states.find(e=>e.name===t.state)}function y(t,e){return t.eventReactionCouplings.filter(o=>o.eventName===e[0])}function c(t,e){t.eventQueue.push(e),t.isTransitioning===!1&&T(t)}var Q=c;function T(t){for(t.isTransitioning=!0;t.eventQueue.length>0&&t.isPaused===!1;)g(t);t.isTransitioning=!1,Object.values(t.subscriptionsToSettledState).forEach(e=>{e(t)})}function g(t){let e=t.eventQueue.shift();if(typeof e<"u"){let o=P(t),i=y(o,e).map(s=>s.reactions).flat(),{sideEffects:r,contextMutations:u,peerings:x,goto_:p}=b(i),d=t.context;u.forEach(s=>{t.context=s.fn(t.context,e,t)}),p!==null&&(c(t,["exit",null]),t.state=p.targetStateName,Object.values(t.subscriptionsToState).forEach(s=>{s(e,t)}),c(t,["entry",null])),x.forEach(s=>{s.type==="SetPeer"?f(t,s.name,s.peerCreationFunction(t.context,e,t)):s.type==="SetPeers"?S(t,s.name,s.peerCreationFunction(t.context,e,t)):s.type==="AddPeers"&&E(t,s.name,s.peerCreationFunction(t.context,e,t))}),Object.values(t.subscriptionsToEvents).forEach(s=>{s(e,t)}),r.forEach(s=>{s.fn(t.context,e,t,d)})}}function b(t){let e=[],o=[],n=[],i=null;return t.forEach(r=>{r.type==="SideEffect"?e.push(r):r.type==="ContextMutation"?o.push(r):r.type==="SetPeer"?n.push(r):r.type==="Goto"&&(i=r)}),{sideEffects:e,contextMutations:o,peerings:n,goto_:i}}var a=0;function I(t,e){return a++,t.subscriptionsToSettledState[a.toString()]=e,a.toString()}var j=I;function N(t,e){return a++,t.subscriptionsToState[a.toString()]=e,a.toString()}function C(t,e){return a++,t.subscriptionsToEvents[a.toString()]=e,a.toString()}function _(t,e){delete t.subscriptionsToSettledState[e.toString()],delete t.subscriptionsToState[e.toString()],delete t.subscriptionsToEvents[e.toString()]}function f(t,e,o){t.peers.hasOwnProperty(e)&&_(t,t.peerSubscriptionIds.get(t.peers[e])),t.peers[e]=o;let n=C(o,(i,r)=>{t.isTransitioning===!1&&c(t,[e+"."+i[0],i[1]])});t.peerSubscriptionIds.set(o,n)}function S(t,e,o){t.peers.hasOwnProperty(e)&&t.peers[e].forEach(n=>{_(t,t.peerSubscriptionIds.get(n))}),t.peers[e]=o,o.forEach(n=>{let i=C(n,(r,u)=>{t.isTransitioning===!1&&c(t,[e+"."+r[0],r[1]])});t.peerSubscriptionIds.set(n,i)})}function E(t,e,o){t.peers.hasOwnProperty(e)||(t.peers[e]=[]),t.peers[e].concat(o),o.forEach(n=>{let i=C(n,(r,u)=>{t.isTransitioning===!1&&c(t,[e+"."+r[0],r[1]])});t.peerSubscriptionIds.set(n,i)})}export{G as AddPeers,k as Context,M as Goto,O as Interpreter,v as Machine,h as On,R as Peer,w as Peers,F as SideEffect,A as State,E as addPeers,Q as enqueue,m as pause,c as send,f as setPeer,S as setPeers,l as start,I as subscribe,C as subscribeToEvents,j as subscribeToSettledState,N as subscribeToState,_ as unsubscribe}; //# sourceMappingURL=index.js.map diff --git a/dist/index.js.map b/dist/index.js.map index 3318ce0..db51a76 100644 --- a/dist/index.js.map +++ b/dist/index.js.map @@ -1,7 +1,7 @@ { "version": 3, "sources": ["../src/index.ts"], - "sourcesContent": ["export type Event_T = [name:string, payload:any];\nexport interface Machine_T {\n states: Array>\n}\nexport interface State_T {\n name: string;\n eventReactionCouplings: Array>;\n}\nexport interface EventReactionCouplings_T {\n eventName: string;\n reactions: Array>;\n};\nexport type Reaction_T = SideEffect_T | ContextMutation_T | Peer_T | Goto_T;\nexport interface SideEffect_T {\n type: 'SideEffect';\n fn: SideEffectFunction_T;\n};\nexport type SideEffectFunction_T = (ctx:C,e:Event_T,self:Interpreter_T,originalContext:C)=>void;\nexport interface ContextMutation_T {\n type: 'ContextMutation';\n fn: ContextMutationFunction_T;\n};\nexport type ContextMutationFunction_T = (ctx:C,e:Event_T,self:Interpreter_T)=>C;\nexport interface Peer_T {\n type: 'SetPeer' | 'SetPeers' | 'AddPeers';\n name: string;\n peerCreationFunction: PeerCreationFunction_T\n};\nexport type PeerCreationFunction_T = (ctx:C,e:Event_T,self:Interpreter_T) => Interpreter_T | Array>;\nexport interface Goto_T {\n type: 'Goto';\n targetStateName: string;\n};\n\nexport const Machine = function(...states:Array>) : Machine_T { return {states}; };\nexport const State = function(name:string, ...eventReactionCouplings:Array>) : State_T{ return {name, eventReactionCouplings}; };\nexport const On = function(eventName:string, ...reactions:Array>) : EventReactionCouplings_T{ return {eventName, reactions}; };\nexport const SideEffect = function(fn:SideEffectFunction_T) : SideEffect_T{ return {type:'SideEffect', fn}; };\nexport const Goto = function(targetStateName:string) : Goto_T { return {type:'Goto', targetStateName} };\nexport const Context = function(fn:ContextMutationFunction_T) : ContextMutation_T { return {type:'ContextMutation', fn} };\nexport const Peer = function(name:string, peerCreationFunction:PeerCreationFunction_T) : Peer_T{ return {type:'SetPeer', name, peerCreationFunction}; }\nexport const Peers = function(name:string, peerCreationFunction:PeerCreationFunction_T) : Peer_T{ return {type:'SetPeers', name, peerCreationFunction}; }\nexport const AddPeers = function(name:string, peerCreationFunction:PeerCreationFunction_T) : Peer_T{ return {type:'AddPeers', name, peerCreationFunction}; }\n\n\nexport interface Interpreter_T {\n machine: Machine_T;\n state: string;\n context: C;\n peers: Record | Array>>;\n peerSubscriptionIds: Map,string>;\n eventQueue:Array;\n subscriptionsToEvents: Record>; // called upon every event\n subscriptionsToState: Record>; // every time state changes, even if it's transient\n subscriptionsToSettledState: Record>; // only called when tick settles\n isTransitioning: boolean;\n isPaused: boolean;\n start: ()=>Interpreter_T;\n Peer: (name:string, peer:Interpreter_T)=>Interpreter_T;\n Peers: (name:string, peers:Array>)=>Interpreter_T;\n}\n\n/**\n * Description placeholder\n *\n * @export\n * @param {Machine_T} machine\n * @param {any} initialContext\n * @param {?string} [initialStateName]\n * @returns {Interpreter_T}\n */\nexport function Interpreter(machine:Machine_T, initialContext:any, initialStateName?:string) : Interpreter_T{\n if(typeof initialStateName === 'undefined'){ initialStateName = machine.states[0].name; }\n //@ts-expect-error\n const interpreter : Interpreter_T = {machine, state: initialStateName, context:initialContext, eventQueue:[], isTransitioning:false, peers:{}, peerSubscriptionIds:new Map(), subscriptionsToEvents: {}, subscriptionsToState: {}, subscriptionsToSettledState: {}, isPaused: true};\n interpreter.start = ()=>{ start(interpreter); return interpreter; }\n interpreter.Peer = (name:string, peer:Interpreter_T)=>{ setPeer(interpreter, name, peer); return interpreter; }\n interpreter.Peers = (name:string, peers:Array>)=>{ setPeers(interpreter, name, peers); return interpreter; }\n send(interpreter, ['entry', null] );\n return interpreter;\n}\nexport function start(interpreter:Interpreter_T){\n if(interpreter.isPaused === true){\n interpreter.isPaused = false;\n processEvents(interpreter);\n }\n}\nexport function pause(interpreter:Interpreter_T){\n if(interpreter.isPaused === false){\n interpreter.isPaused = true;\n }\n}\n\n/** Helper function for `send()`\n */\nfunction getState(interpreter : Interpreter_T) : State_T{\n return interpreter.machine.states.find((state)=>state.name===interpreter.state) as unknown as State_T;\n}\n/** Helper function for `send()`\n */\nfunction getMatchingEventReactionCouplings(state : State_T, event:Event_T) : Array>{\n return state.eventReactionCouplings.filter((eventReactionCoupling)=>eventReactionCoupling.eventName===event[0]);\n}\n/** Inject an Event into the Interpreter's \"tick queue\".\n * \n * An event can be signify something \"new\" happening, such that its reactions should run on the next Tick;\n * or it can signify a milestone \"within\" the current Tick, such that a Tick can be thought of as having \n * \"sub-Ticks\".\n * \n * This distinction is significant for proper ordering of reaction execution, and also for determining\n * whether to run a reaction at all. If an Event is received, and is specified to be applied on a past \n * Tick, it is discarded.\n */\nexport function send(interpreter : Interpreter_T, event:Event_T){\n interpreter.eventQueue.push(event);\n if(interpreter.isTransitioning === false){\n processEvents(interpreter);\n }\n}\nexport const enqueue = send;\nfunction processEvents(interpreter:Interpreter_T){\n interpreter.isTransitioning = true;\n while(interpreter.eventQueue.length > 0 && interpreter.isPaused===false){\n processNextEvent(interpreter);\n }\n interpreter.isTransitioning = false;\n // only run subscriptions here, once the machine's state has settled:\n Object.values(interpreter.subscriptionsToSettledState).forEach((callbackFunction)=>{ callbackFunction(interpreter); });\n}\nfunction processNextEvent(interpreter:Interpreter_T){\n const event = interpreter.eventQueue.shift();\n if(typeof event !== 'undefined'){\n const state = getState(interpreter);\n const eventReactionCouplings = getMatchingEventReactionCouplings(state, event);\n const reactions = eventReactionCouplings\n .map((eventReactionCoupling)=>eventReactionCoupling.reactions)\n .flat();\n const {sideEffects, contextMutations, peerings, goto_} = categorizeReactions(reactions);\n // save the current context, before it's mutated, so as to pass it to sideEffects below:\n const originalContext = interpreter.context;\n // must process contextMutations in-series:\n contextMutations.forEach((contextMutation:ContextMutation_T)=>{\n interpreter.context = contextMutation.fn(interpreter.context, event, interpreter);\n });\n // processing of `goto` must be last:\n if(goto_ !== null){\n send(interpreter, ['exit', null]);\n interpreter.state = goto_.targetStateName;\n // run subscription-to-state callbacks (can be in parallel), since state just changed, possibly transiently (depends on whether the loop in `processEvents()` runs again):\n Object.values(interpreter.subscriptionsToState).forEach((callbackFunction)=>{ callbackFunction(event, interpreter); });\n send(interpreter, ['entry', null]);\n }\n // now that \"internal\" stuff has been run, we can run \"external\" stuff:\n // process peerings (possibly in parallel):\n peerings.forEach((peering)=>{\n if(peering.type === 'SetPeer'){\n setPeer(interpreter, peering.name, peering.peerCreationFunction(interpreter.context, event, interpreter) as Interpreter_T);\n }\n else if(peering.type === 'SetPeers'){\n setPeers(interpreter, peering.name, peering.peerCreationFunction(interpreter.context, event, interpreter) as Array>);\n }\n else if(peering.type === 'AddPeers'){\n addPeers(interpreter, peering.name, peering.peerCreationFunction(interpreter.context, event, interpreter) as Array>);\n }\n });\n // run subscription-to-events callbacks (can be in parallel), since an event just happened:\n Object.values(interpreter.subscriptionsToEvents).forEach((callbackFunction)=>{ callbackFunction(event, interpreter); });\n // can process sideEffects in parallel (though we currently don't due to the overhead of doing so in Node.js):\n // they're processed *after* the context changes, since that's what most sideEffects would be interested in; but nevertheless the original context is passed in case this sideEffect needs it:\n sideEffects.forEach((sideEffect)=>{\n sideEffect.fn(interpreter.context, event, interpreter, originalContext);\n });\n }\n}\nfunction categorizeReactions(reactions:Array>) : {sideEffects:Array>, contextMutations:Array>, peerings:Array>, goto_:Goto_T|null}{\n let \n sideEffects:Array> = [], \n contextMutations:Array> = [], \n peerings:Array> = [],\n goto_:Goto_T|null = null;\n reactions.forEach((reaction)=>{\n if(reaction.type === 'SideEffect'){\n sideEffects.push(reaction);\n }\n else if(reaction.type === 'ContextMutation'){\n contextMutations.push(reaction);\n }\n else if(reaction.type === 'SetPeer'){\n peerings.push(reaction);\n }\n else if(reaction.type === 'Goto'){\n goto_ = reaction;\n }\n });\n return {sideEffects, contextMutations, peerings, goto_};\n}\n\nexport type EventsSubscriptionCallbackFunction_T = (e:Event_T, self:Interpreter_T)=>void;\nexport type StateSubscriptionCallbackFunction_T = (e:Event_T, self:Interpreter_T)=>void;\nexport type SettledStateSubscriptionCallbackFunction_T = (self:Interpreter_T)=>void; // we don't pass an event, because these only run once state settles, so a whole chain of events could have been responsible for that; it's unlikely a subscriber is interested only in the final one\n// TODO: add subscribeToContext and subscribeToSettledContext functions, to get only changes to context, regardless of events happening or state changing\nlet subscriptionId : number = 0;\nexport function subscribe(interpreter:Interpreter_T, callback:SettledStateSubscriptionCallbackFunction_T){\n subscriptionId++;\n interpreter.subscriptionsToSettledState[subscriptionId.toString()] = callback;\n return subscriptionId.toString();\n}\nexport const subscribeToSettledState = subscribe;\nexport function subscribeToState(interpreter:Interpreter_T, callback:StateSubscriptionCallbackFunction_T){\n subscriptionId++;\n interpreter.subscriptionsToState[subscriptionId.toString()] = callback;\n return subscriptionId.toString();\n}\nexport function subscribeToEvents(interpreter:Interpreter_T, callback:StateSubscriptionCallbackFunction_T){\n subscriptionId++;\n interpreter.subscriptionsToEvents[subscriptionId.toString()] = callback;\n return subscriptionId.toString();\n}\nexport function unsubscribe(interpreter:Interpreter_T, subscriptionId:string){\n delete interpreter.subscriptionsToSettledState[subscriptionId.toString()];\n delete interpreter.subscriptionsToState[subscriptionId.toString()];\n delete interpreter.subscriptionsToEvents[subscriptionId.toString()];\n}\n\nexport function setPeer(self:Interpreter_T, name:string, peer:Interpreter_T){\n // if it exists, unsubscribe:\n if(self.peers.hasOwnProperty(name)){\n unsubscribe(self, self.peerSubscriptionIds.get(self.peers[name] as Interpreter_T));\n }\n self.peers[name] = peer;\n const subscriptionId = subscribeToEvents(peer, (e, peer)=>{\n // TODO: ensure there's no faulty logic in having this `if`:\n // this `if` prevents infinite loops due to mutually-subscribed peers (cyclical dependencies):\n if(self.isTransitioning === false){\n send(self, [name+'.'+e[0], e[1]]);\n }\n });\n self.peerSubscriptionIds.set(peer, subscriptionId);\n}\nexport function setPeers(self:Interpreter_T, name:string, peers:Array>){\n // if any exist, unsubscribe:\n if(self.peers.hasOwnProperty(name)){\n (self.peers[name] as Array>).forEach(peer => {\n unsubscribe(self, self.peerSubscriptionIds.get(peer));\n });\n }\n self.peers[name] = peers;\n peers.forEach((peer)=>{\n const subscriptionId = subscribeToEvents(peer, (e, peer)=>{\n // TODO: ensure there's no faulty logic in having this `if`:\n // this `if` prevents infinite loops due to mutually-subscribed peers (cyclical dependencies):\n if(self.isTransitioning === false){\n send(self, [name+'.'+e[0], e[1]]);\n }\n });\n self.peerSubscriptionIds.set(peer, subscriptionId);\n });\n}\nexport function addPeers(self:Interpreter_T, name:string, peers:Array>){\n // if none exist, initialize with empty array:\n if(!self.peers.hasOwnProperty(name)){\n self.peers[name] = [];\n }\n (self.peers[name] as Array>).concat(peers);\n peers.forEach((peer)=>{\n const subscriptionId = subscribeToEvents(peer, (e, peer)=>{\n // TODO: ensure there's no faulty logic in having this `if`:\n // this `if` prevents infinite loops due to mutually-subscribed peers (cyclical dependencies):\n if(self.isTransitioning === false){\n send(self, [name+'.'+e[0], e[1]]);\n }\n });\n self.peerSubscriptionIds.set(peer, subscriptionId);\n });\n}\n\n/*\nexport function useMachine(machine, options){\n return useMemo(()=>interpret(AppMachine, {context:{}}),[]);\n}\n*/"], - "mappings": "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", + "sourcesContent": ["export type Event_T = [name:string, payload:any];\nexport interface Machine_T {\n states: Array>\n}\nexport interface State_T {\n name: string;\n eventReactionCouplings: Array>;\n}\nexport interface EventReactionCouplings_T {\n eventName: string;\n reactions: Array>;\n};\nexport type Reaction_T = SideEffect_T | ContextMutation_T | Peer_T | Goto_T;\nexport interface SideEffect_T {\n type: 'SideEffect';\n fn: SideEffectFunction_T;\n};\nexport type SideEffectFunction_T = (ctx:C,e:Event_T,self:Interpreter_T,originalContext:C)=>void;\nexport interface ContextMutation_T {\n type: 'ContextMutation';\n fn: ContextMutationFunction_T;\n};\nexport type ContextMutationFunction_T = (ctx:C,e:Event_T,self:Interpreter_T)=>C;\nexport interface Peer_T {\n type: 'SetPeer' | 'SetPeers' | 'AddPeers';\n name: string;\n peerCreationFunction: PeerCreationFunction_T\n};\nexport type PeerCreationFunction_T = (ctx:C,e:Event_T,self:Interpreter_T) => Interpreter_T | Array>;\nexport interface Goto_T {\n type: 'Goto';\n targetStateName: string;\n};\n\nexport const Machine = function(...states:Array>) : Machine_T { return {states}; };\nexport const State = function(name:string, ...eventReactionCouplings:Array>) : State_T{ return {name, eventReactionCouplings}; };\nexport const On = function(eventName:string, ...reactions:Array>) : EventReactionCouplings_T{ return {eventName, reactions}; };\nexport const SideEffect = function(fn:SideEffectFunction_T) : SideEffect_T{ return {type:'SideEffect', fn}; };\nexport const Goto = function(targetStateName:string) : Goto_T { return {type:'Goto', targetStateName} };\nexport const Context = function(fn:ContextMutationFunction_T) : ContextMutation_T { return {type:'ContextMutation', fn} };\nexport const Peer = function(name:string, peerCreationFunction:PeerCreationFunction_T) : Peer_T{ return {type:'SetPeer', name, peerCreationFunction}; }\nexport const Peers = function(name:string, peerCreationFunction:PeerCreationFunction_T) : Peer_T{ return {type:'SetPeers', name, peerCreationFunction}; }\nexport const AddPeers = function(name:string, peerCreationFunction:PeerCreationFunction_T) : Peer_T{ return {type:'AddPeers', name, peerCreationFunction}; }\n\n\nexport interface Interpreter_T {\n machine: Machine_T;\n state: string;\n context: C;\n peers: Record | Array>>;\n peerSubscriptionIds: Map,string>;\n eventQueue:Array;\n subscriptionsToEvents: Record>; // called upon every event\n subscriptionsToState: Record>; // every time state changes, even if it's transient\n subscriptionsToSettledState: Record>; // only called when tick settles\n isTransitioning: boolean;\n isPaused: boolean;\n start: ()=>Interpreter_T;\n Peer: (name:string, peer:Interpreter_T)=>Interpreter_T;\n Peers: (name:string, peers:Array>)=>Interpreter_T;\n}\n\n/**\n * Description placeholder\n *\n * @export\n * @param {Machine_T} machine\n * @param {any} initialContext\n * @param {?string} [initialStateName]\n * @returns {Interpreter_T}\n */\nexport function Interpreter(machine:Machine_T, initialContext:any, initialStateName?:string) : Interpreter_T{\n if(typeof initialStateName === 'undefined'){ initialStateName = machine.states[0].name; }\n //@ts-expect-error\n const interpreter : Interpreter_T = {machine, state: initialStateName, context:initialContext, eventQueue:[], isTransitioning:false, peers:{}, peerSubscriptionIds:new Map(), subscriptionsToEvents: {}, subscriptionsToState: {}, subscriptionsToSettledState: {}, isPaused: true};\n interpreter.start = ()=>{ start(interpreter); return interpreter; }\n interpreter.Peer = (name:string, peer:Interpreter_T)=>{ setPeer(interpreter, name, peer); return interpreter; }\n interpreter.Peers = (name:string, peers:Array>)=>{ setPeers(interpreter, name, peers); return interpreter; }\n send(interpreter, ['entry', null] );\n return interpreter;\n}\nexport function start(interpreter:Interpreter_T){\n if(interpreter.isPaused === true){\n interpreter.isPaused = false;\n processEvents(interpreter);\n }\n}\nexport function pause(interpreter:Interpreter_T){\n if(interpreter.isPaused === false){\n interpreter.isPaused = true;\n }\n}\n\n/** Helper function for `send()`\n */\nfunction getState(interpreter : Interpreter_T) : State_T{\n return interpreter.machine.states.find((state)=>state.name===interpreter.state) as unknown as State_T;\n}\n/** Helper function for `send()`\n */\nfunction getMatchingEventReactionCouplings(state : State_T, event:Event_T) : Array>{\n return state.eventReactionCouplings.filter((eventReactionCoupling)=>eventReactionCoupling.eventName===event[0]);\n}\n/** Inject an Event into the Interpreter's \"tick queue\".\n * \n * An event can be signify something \"new\" happening, such that its reactions should run on the next Tick;\n * or it can signify a milestone \"within\" the current Tick, such that a Tick can be thought of as having \n * \"sub-Ticks\".\n * \n * This distinction is significant for proper ordering of reaction execution, and also for determining\n * whether to run a reaction at all. If an Event is received, and is specified to be applied on a past \n * Tick, it is discarded.\n */\nexport function send(interpreter : Interpreter_T, event:Event_T){\n interpreter.eventQueue.push(event);\n if(interpreter.isTransitioning === false){\n processEvents(interpreter);\n }\n}\nexport const enqueue = send;\nfunction processEvents(interpreter:Interpreter_T){\n interpreter.isTransitioning = true;\n while(interpreter.eventQueue.length > 0 && interpreter.isPaused===false){\n processNextEvent(interpreter);\n }\n interpreter.isTransitioning = false;\n // only run subscriptions here, once the machine's state has settled:\n Object.values(interpreter.subscriptionsToSettledState).forEach((callbackFunction)=>{ callbackFunction(interpreter); });\n}\nfunction processNextEvent(interpreter:Interpreter_T){\n const event = interpreter.eventQueue.shift();\n if(typeof event !== 'undefined'){\n const state = getState(interpreter);\n const eventReactionCouplings = getMatchingEventReactionCouplings(state, event);\n const reactions = eventReactionCouplings\n .map((eventReactionCoupling)=>eventReactionCoupling.reactions)\n .flat();\n const {sideEffects, contextMutations, peerings, goto_} = categorizeReactions(reactions);\n // save the current context, before it's mutated, so as to pass it to sideEffects below:\n const originalContext = interpreter.context;\n // must process contextMutations in-series:\n contextMutations.forEach((contextMutation:ContextMutation_T)=>{\n interpreter.context = contextMutation.fn(interpreter.context, event, interpreter);\n });\n // processing of `goto` must be last:\n if(goto_ !== null){\n send(interpreter, ['exit', null]);\n interpreter.state = goto_.targetStateName;\n // run subscription-to-state callbacks (can be in parallel), since state just changed, possibly transiently (depends on whether the loop in `processEvents()` runs again):\n Object.values(interpreter.subscriptionsToState).forEach((callbackFunction)=>{ callbackFunction(event, interpreter); });\n send(interpreter, ['entry', null]);\n }\n // now that \"internal\" stuff has been run, we can run \"external\" stuff:\n // process peerings (possibly in parallel):\n peerings.forEach((peering)=>{\n if(peering.type === 'SetPeer'){\n setPeer(interpreter, peering.name, peering.peerCreationFunction(interpreter.context, event, interpreter) as Interpreter_T);\n }\n else if(peering.type === 'SetPeers'){\n setPeers(interpreter, peering.name, peering.peerCreationFunction(interpreter.context, event, interpreter) as Array>);\n }\n else if(peering.type === 'AddPeers'){\n addPeers(interpreter, peering.name, peering.peerCreationFunction(interpreter.context, event, interpreter) as Array>);\n }\n });\n // run subscription-to-events callbacks (can be in parallel), since an event just happened:\n Object.values(interpreter.subscriptionsToEvents).forEach((callbackFunction)=>{ callbackFunction(event, interpreter); });\n // can process sideEffects in parallel (though we currently don't due to the overhead of doing so in Node.js):\n // they're processed *after* the context changes, since that's what most sideEffects would be interested in; but nevertheless the original context is passed in case this sideEffect needs it:\n sideEffects.forEach((sideEffect)=>{\n sideEffect.fn(interpreter.context, event, interpreter, originalContext);\n });\n }\n}\nfunction categorizeReactions(reactions:Array>) : {sideEffects:Array>, contextMutations:Array>, peerings:Array>, goto_:Goto_T|null}{\n let \n sideEffects:Array> = [], \n contextMutations:Array> = [], \n peerings:Array> = [],\n goto_:Goto_T|null = null;\n reactions.forEach((reaction)=>{\n if(reaction.type === 'SideEffect'){\n sideEffects.push(reaction);\n }\n else if(reaction.type === 'ContextMutation'){\n contextMutations.push(reaction);\n }\n else if(reaction.type === 'SetPeer'){\n peerings.push(reaction);\n }\n else if(reaction.type === 'Goto'){\n goto_ = reaction;\n }\n });\n return {sideEffects, contextMutations, peerings, goto_};\n}\n\nexport type EventsSubscriptionCallbackFunction_T = (e:Event_T, self:Interpreter_T)=>void;\nexport type StateSubscriptionCallbackFunction_T = (e:Event_T, self:Interpreter_T)=>void;\nexport type SettledStateSubscriptionCallbackFunction_T = (self:Interpreter_T)=>void; // we don't pass an event, because these only run once state settles, so a whole chain of events could have been responsible for that; it's unlikely a subscriber is interested only in the final one\n// TODO: add subscribeToContext and subscribeToSettledContext functions, to get only changes to context, regardless of events happening or state changing\nlet subscriptionId : number = 0;\nexport function subscribe(interpreter:Interpreter_T, callback:SettledStateSubscriptionCallbackFunction_T){\n subscriptionId++;\n interpreter.subscriptionsToSettledState[subscriptionId.toString()] = callback;\n return subscriptionId.toString();\n}\nexport const subscribeToSettledState = subscribe;\nexport function subscribeToState(interpreter:Interpreter_T, callback:StateSubscriptionCallbackFunction_T){\n subscriptionId++;\n interpreter.subscriptionsToState[subscriptionId.toString()] = callback;\n return subscriptionId.toString();\n}\nexport function subscribeToEvents(interpreter:Interpreter_T, callback:StateSubscriptionCallbackFunction_T){\n subscriptionId++;\n interpreter.subscriptionsToEvents[subscriptionId.toString()] = callback;\n return subscriptionId.toString();\n}\nexport function unsubscribe(interpreter:Interpreter_T, subscriptionId:string){\n delete interpreter.subscriptionsToSettledState[subscriptionId.toString()];\n delete interpreter.subscriptionsToState[subscriptionId.toString()];\n delete interpreter.subscriptionsToEvents[subscriptionId.toString()];\n}\n\nexport function setPeer(self:Interpreter_T, name:string, peer:Interpreter_T){\n // if it exists, unsubscribe:\n if(self.peers.hasOwnProperty(name)){\n unsubscribe(self, self.peerSubscriptionIds.get(self.peers[name] as Interpreter_T));\n }\n self.peers[name] = peer;\n const subscriptionId = subscribeToEvents(peer, (e, peer)=>{\n // TODO: ensure there's no faulty logic in having this `if`:\n // this `if` prevents infinite loops due to mutually-subscribed peers (cyclical dependencies):\n if(self.isTransitioning === false){\n send(self, [name+'.'+e[0], e[1]]);\n }\n });\n self.peerSubscriptionIds.set(peer, subscriptionId);\n}\nexport function setPeers(self:Interpreter_T, name:string, peers:Array>){\n // if any exist, unsubscribe:\n if(self.peers.hasOwnProperty(name)){\n (self.peers[name] as Array>).forEach(peer => {\n unsubscribe(self, self.peerSubscriptionIds.get(peer));\n });\n }\n self.peers[name] = peers;\n peers.forEach((peer)=>{\n const subscriptionId = subscribeToEvents(peer, (e, peer)=>{\n // TODO: ensure there's no faulty logic in having this `if`:\n // this `if` prevents infinite loops due to mutually-subscribed peers (cyclical dependencies):\n if(self.isTransitioning === false){\n send(self, [name+'.'+e[0], e[1]]);\n }\n });\n self.peerSubscriptionIds.set(peer, subscriptionId);\n });\n}\nexport function addPeers(self:Interpreter_T, name:string, peers:Array>){\n // if none exist, initialize with empty array:\n if(!self.peers.hasOwnProperty(name)){\n self.peers[name] = [];\n }\n (self.peers[name] as Array>).concat(peers);\n peers.forEach((peer)=>{\n const subscriptionId = subscribeToEvents(peer, (e, peer)=>{\n // TODO: ensure there's no faulty logic in having this `if`:\n // this `if` prevents infinite loops due to mutually-subscribed peers (cyclical dependencies):\n if(self.isTransitioning === false){\n send(self, [name+'.'+e[0], e[1]]);\n }\n });\n self.peerSubscriptionIds.set(peer, subscriptionId);\n });\n}\n\n/*\nexport function useMachine(machine, options){\n return useMemo(()=>interpret(AppMachine, {context:{}}),[]);\n}\n*/"], + "mappings": "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", "names": ["Machine", "states", "State", "name", "eventReactionCouplings", "On", "eventName", "reactions", "SideEffect", "fn", "Goto", "targetStateName", "Context", "Peer", "peerCreationFunction", "Peers", "AddPeers", "Interpreter", "machine", "initialContext", "initialStateName", "interpreter", "start", "peer", "setPeer", "peers", "setPeers", "send", "processEvents", "pause", "getState", "state", "getMatchingEventReactionCouplings", "event", "eventReactionCoupling", "enqueue", "processNextEvent", "callbackFunction", "sideEffects", "contextMutations", "peerings", "goto_", "categorizeReactions", "originalContext", "contextMutation", "peering", "addPeers", "sideEffect", "reaction", "subscriptionId", "subscribe", "callback", "subscribeToSettledState", "subscribeToState", "subscribeToEvents", "unsubscribe", "self", "e"] } diff --git a/src/index.ts b/src/index.ts index 3b9625e..b94d771 100644 --- a/src/index.ts +++ b/src/index.ts @@ -56,8 +56,8 @@ export interface Interpreter_T { isTransitioning: boolean; isPaused: boolean; start: ()=>Interpreter_T; - Peer: (name:string, peer:Interpreter_T)=>Interpreter_T; - Peers: (name:string, peers:Array>)=>Interpreter_T; + Peer: (name:string, peer:Interpreter_T)=>Interpreter_T; + Peers: (name:string, peers:Array>)=>Interpreter_T; } /** @@ -74,8 +74,8 @@ export function Interpreter(machine:Machine_T, initialContext:any, initial //@ts-expect-error const interpreter : Interpreter_T = {machine, state: initialStateName, context:initialContext, eventQueue:[], isTransitioning:false, peers:{}, peerSubscriptionIds:new Map(), subscriptionsToEvents: {}, subscriptionsToState: {}, subscriptionsToSettledState: {}, isPaused: true}; interpreter.start = ()=>{ start(interpreter); return interpreter; } - interpreter.Peer = (name:string, peer:Interpreter_T)=>{ setPeer(interpreter, name, peer); return interpreter; } - interpreter.Peers = (name:string, peers:Array>)=>{ setPeers(interpreter, name, peers); return interpreter; } + interpreter.Peer = (name:string, peer:Interpreter_T)=>{ setPeer(interpreter, name, peer); return interpreter; } + interpreter.Peers = (name:string, peers:Array>)=>{ setPeers(interpreter, name, peers); return interpreter; } send(interpreter, ['entry', null] ); return interpreter; }