UI

README.md

@@ -39,7 +39,11 @@ Or simply, due to the recursive functionality of STRX, that requires the ability
 // ./src/test/ownership.test.ts
 const orderOfTopics: string[] = [];
 let finalRun = true;
-const axium = createAxium(['ownershipTest', createOwnershipConcept(), createCounterConcept(), createExperimentConcept()], true, true);
+const axium = createAxium('ownershipTest', [
+  createOwnershipConcept(),
+  createCounterConcept(),
+  createExperimentConcept(createExperimentActionQueState(), [checkInQuality], [experimentActionQuePrinciple])
+], true, true);
 const staged = axium.stage(
   'Testing Ownership Staging', [
     (cpts, dispatch) => {
@@ -68,7 +72,7 @@ const staged = axium.stage(
       console.log('Stage 3', ownership.ownershipLedger, ownership.pendingActions);
       const counter = selectState<Counter>(cpts, counterName);
       console.log('Count: ', counter.count);
-      dispatch(strategyBegin(primedCountingStrategy(cpts)), {
+      dispatch(strategyBegin(experimentPrimedCountingStrategy(cpts)), {
         iterateStep: true
       });
     },
@@ -80,20 +84,20 @@ const staged = axium.stage(
         finalRun = false;
         // This will be the final test to be triggered by a log action.
         console.log('Stage 3, If #3 | Count: ', counter.count, orderOfTopics);
-        expect(orderOfTopics[0]).toBe(countingTopic);
+        expect(orderOfTopics[0]).toBe(experimentCountingTopic);
         expect(counter.count).toBe(3);
         // Comment in if testing the halting ability of log and setCount stage is commented out.
         // setTimeout(() => {done();}, 1000);
         staged.close();
       } else if (
-        (axiumState.lastStrategy === countingTopic ||
-        axiumState.lastStrategy === primedCountingTopic) &&
+        (axiumState.lastStrategy === experimentCountingTopic ||
+        axiumState.lastStrategy === experimentPrimedCountingTopic) &&
         orderOfTopics.length === 0) {
         console.log('Stage 3, If #1 | Count: ', counter.count);
         orderOfTopics.push(axiumState.lastStrategy);
       } else if (
-        (axiumState.lastStrategy === countingTopic ||
-        axiumState.lastStrategy === primedCountingTopic) &&
+        (axiumState.lastStrategy === experimentCountingTopic ||
+        axiumState.lastStrategy === experimentPrimedCountingTopic) &&
         orderOfTopics.length === 1) {
         if (orderOfTopics[0] !== axiumState.lastStrategy) {
           console.log('Stage 3, If #2 | Count: ', counter.count);

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phuire/strx",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "description": "Unified Turing Machine",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

src/concepts/axium/axium.concept.ts

@@ -1,5 +1,5 @@
-import { BehaviorSubject, Subject, Subscriber } from 'rxjs';
-import { Concept, ConceptCreator } from '../../model/concept';
+import { Subject, Subscriber } from 'rxjs';
+import { Concept } from '../../model/concept';
 import { Action } from '../../model/action';
 import { axiumPrinciple } from './axium.principle';
 import { blockingMode, permissiveMode } from './axium.mode';

src/concepts/chain/chain.concept.ts

@@ -1,5 +1,5 @@
 import { Action } from '../../index';
-import { ConceptCreator, createConcept } from '../../model/concept';
+import { createConcept } from '../../model/concept';
 import { chainPrinciple } from './chain.principle';
 import { prepareChainQuality } from './qualities/prepareChain.quality';
 
@@ -13,7 +13,7 @@ const initialChainState: Chain = {
   actionQue: [],
 };
 
-export const createChainConcept: ConceptCreator = () => {
+export const createChainConcept = () => {
   return createConcept(
     chainName,
     initialChainState,

src/concepts/counter/counter.concept.ts

@@ -1,7 +1,7 @@
 import { addQuality } from './qualities/add.quality';
 import { subtractQuality } from './qualities/subtract.quality';
 import { setCountQuality } from './qualities/setCount.quality';
-import { ConceptCreator, createConcept } from '../../model/concept';
+import { createConcept } from '../../model/concept';
 export { countingStrategy, primedCountingStrategy } from './strategies/counting.strategy';
 
 export type Counter = {
@@ -14,7 +14,7 @@ const initialCounterState: Counter = {
   count: 0
 };
 
-export const createCounterConcept: ConceptCreator = () => {
+export const createCounterConcept = () => {
   return createConcept(
     counterName,
     initialCounterState,

src/concepts/experiment/experiment.concept.ts

@@ -1,30 +1,29 @@
-import { ConceptCreator, createConcept } from '../../model/concept';
+import { Mode, Quality, createConcept } from '../../model/concept';
 import { Action } from '../../model/action';
-import { checkInQuality } from './qualities/checkIn.quality';
-import { experimentPrinciple } from './experiment.principle';
+import { PrincipleFunction } from '../../model/principle';
 
-export type ExperimentState = {
+export type ExperimentActionQueState = {
   actionQue: Action[],
 }
 
 export const experimentName = 'experiment';
 
-const createExperimentState = (): ExperimentState => {
+export const createExperimentActionQueState = (): ExperimentActionQueState => {
   return {
     actionQue: [],
   };
 };
 
-export const createExperimentConcept: ConceptCreator = () => {
+export const createExperimentConcept = (
+  state: any,
+  qualities?: Quality[],
+  principles?: PrincipleFunction[],
+  mode?: Mode[]) => {
   return createConcept(
     experimentName,
-    createExperimentState(),
-    [
-      checkInQuality
-    ],
-    [
-      experimentPrinciple
-    ],
-    []
+    state,
+    qualities,
+    principles,
+    mode
   );
 };

src/concepts/experiment/experiment.principle.ts

@@ -5,9 +5,9 @@ import { Concept } from '../../model/concept';
 import { UnifiedSubject } from '../../model/unifiedSubject';
 import { selectState } from '../../model/selector';
 import { AxiumState, axiumName } from '../axium/axium.concept';
-import { ExperimentState, experimentName } from './experiment.concept';
+import { ExperimentActionQueState, experimentName } from './experiment.concept';
 
-export const experimentPrinciple: PrincipleFunction = (
+export const experimentActionQuePrinciple: PrincipleFunction = (
   observer: Subscriber<Action>,
   _concepts: Concept[],
   concepts$: UnifiedSubject
@@ -18,7 +18,7 @@ export const experimentPrinciple: PrincipleFunction = (
     if (axiumState.open) {
       const subscription = concepts$.subscribe(cpts => {
         const concepts = cpts;
-        const experimentState = selectState<ExperimentState>(concepts, experimentName);
+        const experimentState = selectState<ExperimentActionQueState>(concepts, experimentName);
         // console.log('Check que', experimentState.actionQue);
         if (experimentState.actionQue.length > 0) {
           if (!readyToGo) {

src/concepts/experiment/qualities/checkIn.quality.ts

@@ -1,15 +1,15 @@
 import { defaultMethodCreator, defaultReducer } from '../../../model/concept';
 import { Action, prepareActionCreator } from '../../../model/action';
 import { createQuality } from '../../../model/concept';
-import { ExperimentState } from '../experiment.concept';
 import { strategySuccess } from '../../../model/actionStrategy';
 import { axiumConcludeType } from '../../axium/qualities/conclude.quality';
+import { ExperimentActionQueState } from '../experiment.concept';
 
 export const experimentCheckInType = 'Experiment Check in Action';
 
 export const experimentCheckIn = prepareActionCreator(experimentCheckInType);
 
-export function checkInReducer(state: ExperimentState, action: Action): ExperimentState {
+export function checkInReducer(state: ExperimentActionQueState, action: Action): ExperimentActionQueState {
   if (action.strategy) {
     // console.log('Check in reducer', action);
     const nextAction = strategySuccess(action.strategy);

src/concepts/experiment/strategies/experimentCounting.strategy.ts

@@ -8,8 +8,8 @@ import { counterSelectCount } from '../../counter/counter.selector';
 import { ownershipBackTrackType } from '../../ownership/qualities/backTrack.quality';
 import { ownershipName } from '../../ownership/ownership.concept';
 
-export const countingTopic = 'Counting Strategy';
-export function countingStrategy(): ActionStrategy {
+export const experimentCountingTopic = 'Counting Strategy';
+export function experimentCountingStrategy(): ActionStrategy {
   const backTrack: ActionNode = {
     actionType: ownershipBackTrackType,
     successNode: null,
@@ -72,15 +72,15 @@ export function countingStrategy(): ActionStrategy {
   };
 
   const params: ActionStrategyParameters = {
-    topic: countingTopic,
+    topic: experimentCountingTopic,
     initialNode: stepOne,
   };
 
   return createStrategy(params);
 }
 
-export const primedCountingTopic = 'Counting Strategy with Primed Actions';
-export function primedCountingStrategy(concepts: Concept[]): ActionStrategy {
+export const experimentPrimedCountingTopic = 'Counting Strategy with Primed Actions';
+export function experimentPrimedCountingStrategy(concepts: Concept[]): ActionStrategy {
   const addSemaphore = getSemaphore(concepts, counterName, counterAddType);
   const subtractSemaphore = getSemaphore(concepts, counterName, counterSubtractType);
   const backTrackSemaphore = getSemaphore(concepts, ownershipName, ownershipBackTrackType);
@@ -140,7 +140,7 @@ export function primedCountingStrategy(concepts: Concept[]): ActionStrategy {
   };
 
   const params: ActionStrategyParameters = {
-    topic: primedCountingTopic,
+    topic: experimentPrimedCountingTopic,
     initialNode: stepOne,
   };
 

src/concepts/experiment/strategies/puntCounting.strategy.ts

@@ -1,7 +1,7 @@
 import { ActionNode, ActionStrategy, ActionStrategyParameters, createStrategy, puntStrategy } from '../../../model/actionStrategy';
 import { counterSelectCount } from '../../counter/counter.selector';
 import { experimentCheckInType } from '../qualities/checkIn.quality';
-import { countingStrategy } from './experimentCounting.strategy';
+import { experimentCountingStrategy } from './experimentCounting.strategy';
 
 export const puntCountingStrategyTopic = 'This will Punt the Counting Strategy into the Experiment\'s Action Que';
 export function puntCountingStrategy(): ActionStrategy {
@@ -17,5 +17,5 @@ export function puntCountingStrategy(): ActionStrategy {
     initialNode: stepOne,
   };
 
-  return puntStrategy(countingStrategy(), createStrategy(params));
+  return puntStrategy(experimentCountingStrategy(), createStrategy(params));
 }

src/concepts/ownership/ownership.concept.ts

@@ -1,4 +1,4 @@
-import { ConceptCreator, createConcept } from '../../model/concept';
+import { createConcept } from '../../model/concept';
 import { Action } from '../../model/action';
 import { ownershipMode } from './ownership.mode';
 import { initializeOwnershipQuality } from './qualities/initializeOwnership.quality';
@@ -31,7 +31,7 @@ const createOwnershipState = (isResponsibleForMode?: boolean): OwnershipState =>
   };
 };
 
-export const createOwnershipConcept: ConceptCreator = (isResponsibleForMode?: boolean) => {
+export const createOwnershipConcept = (isResponsibleForMode?: boolean) => {
   return createConcept(
     ownershipName,
     createOwnershipState(isResponsibleForMode ? isResponsibleForMode : true),

src/index.ts

@@ -22,7 +22,6 @@ export type {
   Method,
   Principle,
   Mode,
-  ConceptCreator,
   MethodCreator
 } from './model/concept';
 export type { KeyedSelector } from './model/selector';
@@ -94,4 +93,20 @@ export {
 export {
   ownershipClearStrategyStubsFromLedgerAndSelfType
 } from './concepts/ownership/qualities/clearStrategyStubsFromLedgerAndSelf.quality';
-export { ownershipResetOwnershipLedgerType } from './concepts/ownership/qualities/resetOwnershipLedger.quality';
+export { ownershipResetOwnershipLedgerType } from './concepts/ownership/qualities/resetOwnershipLedger.quality';
+
+// Experiment
+export {
+  ExperimentActionQueState,
+  createExperimentActionQueState,
+  createExperimentConcept,
+  experimentName
+} from './concepts/experiment/experiment.concept';
+export {checkInQuality, experimentCheckIn, experimentCheckInType} from './concepts/experiment/qualities/checkIn.quality';
+export {
+  experimentCountingStrategy,
+  experimentCountingTopic,
+  experimentPrimedCountingStrategy,
+  experimentPrimedCountingTopic
+} from './concepts/experiment/strategies/experimentCounting.strategy';
+export {experimentActionQuePrinciple} from './concepts/experiment/experiment.principle';

src/model/concept.ts

@@ -42,29 +42,18 @@ export type Concept = {
   meta?: Record<string,unknown>;
 };
 
-export type ConceptCreator = (
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  ...args: any[]
-  // name?: string,
-  // state?: unknown,
-  // qualities?: Quality[],
-  // principles?: PrincipleFunction[],
-  // mode?: Mode[],
-  // meta?: Record<string,unknown>
-) => Concept;
-
 export function createConcept(
   name: string,
   state: unknown,
-  qualities: Quality[],
+  qualities?: Quality[],
   principles?: PrincipleFunction[],
   mode?: Mode[],
   meta?: Record<string,unknown>
 ): Concept {
   return {
     name,
     state,
-    qualities,
+    qualities: qualities ? qualities : [],
     principles,
     mode,
     meta

src/model/unifiedSubject.ts

@@ -42,16 +42,22 @@ const handleRun =
     : [StageDelimiter, boolean] => {
     if (options?.on) {
       if (selectSlice(value, options?.on.selector) === options?.on.expected) {
-        const runOnceMap = stageDelimiter.runOnceMap.get(action.type + plan.stage);
-        if (runOnceMap === undefined) {
-          stageDelimiter.runOnceMap.set(action.type + plan.stage, true);
-          return [
-            stageDelimiter, true
-          ];
+        if (options.runOnce) {
+          const runOnceMap = stageDelimiter.runOnceMap.get(action.type + plan.stage);
+          if (runOnceMap === undefined) {
+            stageDelimiter.runOnceMap.set(action.type + plan.stage, true);
+            return [
+              stageDelimiter, true
+            ];
+          } else {
+            stageDelimiter.runOnceMap.set(action.type + plan.stage, false);
+            return [
+              stageDelimiter, false
+            ];
+          }
         } else {
-          stageDelimiter.runOnceMap.set(action.type + plan.stage, false);
           return [
-            stageDelimiter, false
+            stageDelimiter, true
           ];
         }
       } else {
@@ -99,7 +105,7 @@ const handleStageDelimiter =
     } else if (stageDelimiter) {
       stageDelimiter = {
         stage: plan.stage,
-        prevActions: [...stageDelimiter.prevActions ,action.type],
+        prevActions: [...stageDelimiter.prevActions, action.type],
         unionExpiration: [...stageDelimiter.unionExpiration, action.expiration],
         runOnceMap: new Map()
       };
@@ -126,9 +132,10 @@ export class UnifiedSubject extends Subject<Concept[]> {
   }
   stage(title: string, stages: Staging[]) {
     this.currentStages.set(this.stageId, {title, stages, stage: 0, stageFailed: -1});
+    const stageId = this.stageId;
     this.stageId++;
     const close = () => {
-      this.currentStages.delete(this.stageId);
+      this.currentStages.delete(stageId);
     };
     return {
       close: close.bind(this)
@@ -183,7 +190,11 @@ export class UnifiedSubject extends Subject<Concept[]> {
           action$.next(action);
         }
       }
-    } else if (options?.runOnce === undefined) {
+    } else if (
+      options?.runOnce === undefined &&
+      (options.on === undefined ||
+      (options.on && (!options.debounce && (options.iterateStep === undefined || options.setStep === plan.stage)))
+      )) {
       plan.stageFailed = plan.stage;
       plan.stage = plan.stages.length;
       const deleted = this.currentStages.delete(key);