Merge pull request #222 from Phuire-Research/Consistency

v0.1.69

README.md

@@ -49,6 +49,10 @@ When in doubt simplify.
 * [Unified Turing Machine](https://github.com/Phuire-Research/Stratimux/blob/main/The-Unified-Turing-Machine.md) - The governing concept for this entire framework.
 
 ## Change Log ![Tests](https://github.com/Phuire-Research/Stratimux/actions/workflows/node.js.yml/badge.svg)
+### v0.1.69 5/15/2024
+* Added priority to axium strategies.
+* Improved consistency of logic due the above change.
+* Exported **isAxiumOpen** helper function.
 ### Strategy Priority v0.1.68 5/15/2024
 * Added priority to strategies, this priority will be assigned to each step issued by such.
   * With this change you may now have strategies jump all lines upon creation, ensuring some change prior to other action's taking effect.

package.json

@@ -1,7 +1,7 @@
 {
   "name": "stratimux",
   "license": "GPL-3.0",
-  "version": "0.1.68",
+  "version": "0.1.69",
   "description": "Unified Turing Machine",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

src/concepts/axium/axium.principle.ts

@@ -180,7 +180,8 @@ export const axiumPrinciple: PrincipleFunction = (
         failureNode: null
       }),
       failureNode: null
-    })
+    }),
+    priority: Infinity
   })));
 };
 /*#>*/

src/concepts/axium/strategies/addConcept.strategy.ts

@@ -70,6 +70,7 @@ export function addConceptsFromQueThenUnblockStrategy(conceptualSet: Concepts):
   const params: ActionStrategyParameters = {
     topic: addConceptsFromQueThenUnblockTopic,
     initialNode: stepOne,
+    priority: Infinity
   };
 
   return createStrategy(params);

src/concepts/axium/strategies/initialization.strategy.ts

@@ -43,6 +43,7 @@ export function initializationStrategy(concepts: Concepts): ActionStrategy {
   const params: ActionStrategyParameters = {
     topic: initializeTopic,
     initialNode: stepOne,
+    priority: Infinity
   };
 
   return createStrategy(params);

src/concepts/axium/strategies/removeConcept.strategy.ts

@@ -63,6 +63,7 @@ export function removeConceptsViaQueThenUnblockStrategy(concepts: Concepts): Act
   const params: ActionStrategyParameters = {
     topic: removeConceptsViaQueThenUnblockTopic,
     initialNode: stepOne,
+    priority: Infinity
   };
 
   return createStrategy(params);

src/index.ts

@@ -3,7 +3,7 @@ For the asynchronous graph programming framework Stratimux,
 define the current index file that exports all public functionality for the framework as a module.
 $>*/
 /*<#*/
-export { createAxium, getAxiumState, Axium } from './model/axium';
+export { createAxium, getAxiumState, Axium, isAxiumOpen } from './model/axium';
 export type {
   ActionNode,
   ActionNotes,

src/model/axium.ts

@@ -43,13 +43,13 @@ export const blockingMethodSubscription = (concepts: Concepts, tail: Action[], a
       strategyData: action.strategy.data,
     });
     if (isPriorityValid(action)) {
+      appendToDialog.priority = action.priority;
       const state = getAxiumState(concepts);
       handlePriority(state, action);
-      appendToDialog.priority = action.priority;
       handlePriority(state, appendToDialog);
     } else {
-      tail.push(appendToDialog);
       tail.push(action);
+      tail.push(appendToDialog);
     }
   } else if (
     action.strategy &&
@@ -61,7 +61,6 @@ export const blockingMethodSubscription = (concepts: Concepts, tail: Action[], a
     } else {
       tail.push(action);
     }
-    tail.push(action);
   }
 };
 
@@ -84,8 +83,8 @@ export const defaultMethodSubscription = (concepts: Concepts, tail: Action[], ac
       appendToDialog.priority = action.priority;
       handlePriority(state, appendToDialog);
     } else {
-      tail.push(appendToDialog);
       tail.push(action);
+      tail.push(appendToDialog);
     }
     if (async) {
       axiumTimeOut(concepts, () => {

src/model/selector.ts

@@ -208,7 +208,7 @@ export function selectState<T>(concepts: Concepts, name: string): T | undefined
   const length = conceptKeys.length;
   const select = (index: number): T | undefined => {
     if (concepts[conceptKeys[index]].name === name) {
-      return concepts[index].state as T;
+      return concepts[conceptKeys[index]].state as T;
     } else if (index < length - 1) {
       return select(index + 1);
     } else {

src/test/addConcepts.test.ts

@@ -10,12 +10,14 @@ import { addConceptsToAddQueThenBlockStrategy } from '../concepts/axium/strategi
 import { AxiumState } from '../concepts/axium/axium.concept';
 import { countingTopic } from '../concepts/counter/strategies/counting.strategy';
 import { forEachConcept } from '../model/concept';
-import { createStage } from '../model/stagePlanner';
+import { createStage, stageWaitForOpenThenIterate } from '../model/stagePlanner';
 import { axiumSelectOpen } from '../concepts/axium/axium.selector';
+import { axiumKick } from '../concepts/axium/qualities/kick.quality';
 
 test('Axium add Concepts Strategy Test', (done) => {
   const axium = createAxium('axiumAddConceptTest',[], {logging: true, storeDialog: true});
   const plan = axium.plan('Add Concepts Stage',[
+    stageWaitForOpenThenIterate(() => axiumKick()),
     createStage((concepts, dispatch) => {
       console.log('Add Counter Concept');
       dispatch(
@@ -48,7 +50,9 @@ test('Axium add Concepts Strategy Test', (done) => {
       const axiumState = concepts[0].state as AxiumState;
       console.log('Check for final counting topic', axiumState.lastStrategy, concepts[1]?.state);
       if (axiumState.lastStrategy === countingTopic) {
+        console.log('CHECK CONCEPTS', concepts);
         const counter = selectState<CounterState>(concepts, counterName);
+        console.log('SHOULD HIT, but isn\'t');
         expect(counter?.count).toBe(1);
         setTimeout(() => {done();}, 500);
         plan.conclude();

src/test/beatSelectorChanges/beatSelectorChanges.test.ts

@@ -3,7 +3,7 @@ For the asynchronous graph programming framework Stratimux generate a test that
 utilizing the provided BeatSelectorChanges concept
 $>*/
 /*<#*/
-import { createAxium, getAxiumState } from '../../model/axium';
+import { createAxium, getAxiumState, isAxiumOpen } from '../../model/axium';
 import { createStage } from '../../model/stagePlanner';
 import { generateRandomCountingStrategy } from './strategies/generateCountingStrategy.strategy';
 import { beatSelectorChangesName, createBeatSelectorChangesConcept } from './beatSelectorChanges.concept';
@@ -28,7 +28,7 @@ test('Deferred Beat Selector Changes Test', (done) => {
   ]);
   const plan = axium.plan('Prolonged Counting Strategy', [
     createStage((concepts, dispatch) => {
-      if (getAxiumState(concepts).lastStrategy === initializeTopic) {
+      if (isAxiumOpen(concepts)) {
         dispatch(strategyBegin(strategy), {
           iterateStage: true
         });

src/test/onChange.test.ts

@@ -25,6 +25,7 @@ test('Axium onChange Test', (done) => {
   const plan = axium.plan('Counting Strategy Plan with selectors',
     [
       createStage((concepts, dispatch) => {
+        console.log('WHAT IS THIS', selectSlice(concepts, axiumSelectLastStrategy));
         if (selectSlice(concepts, axiumSelectLastStrategy) === initializeTopic) {
           dispatch(strategyBegin(countingStrategy()), {
             iterateStage: true

src/test/setStageOptions.test.ts

@@ -2,7 +2,7 @@
 For the asynchronous graph programming framework Stratimux, generate a test that the setStageOption derivatives.are functioning as intended
 $>*/
 /*<#*/
-import { createAxium } from '../model/axium';
+import { createAxium, isAxiumOpen } from '../model/axium';
 import { strategyBegin } from '../model/actionStrategy';
 import { selectSlice, selectState } from '../model/selector';
 import { CounterState, createCounterConcept, countingStrategy, counterName } from '../concepts/counter/counter.concept';
@@ -19,7 +19,7 @@ test('Axium setStageSelectors Test', (done) => {
   const plan = axium.plan('Counting Strategy Plan using setStageSelectors',
     [
       createStage((concepts, dispatch) => {
-        if (selectSlice(concepts, axiumSelectLastStrategy) === initializeTopic) {
+        if (isAxiumOpen(concepts)) {
           dispatch(strategyBegin(countingStrategy()), {
             iterateStage: true,
             setStageSelectors: {
@@ -54,7 +54,7 @@ test('Axium setStageBeat Test', (done) => {
   const plan = axium.plan('Counting Strategy Plan using setStageBeat',
     [
       createStage((concepts, dispatch) => {
-        if (selectSlice(concepts, axiumSelectLastStrategy) === initializeTopic) {
+        if (isAxiumOpen(concepts)) {
           dispatch(strategyBegin(countingStrategy()), {
             iterateStage: true,
             setStageBeat: {

src/test/strategyPriority.test.ts

@@ -17,10 +17,13 @@ import { handlePriority } from '../model/priority';
 test('Axium Counting Strategy Priority Test', (done) => {
   const concluded = [false, false, false];
   const [count1, strategy1] = generateRandomCountingStrategy(0);
+  strategy1.topic += 1;
   strategy1.priority = 100;
   const [count2, strategy2] = generateRandomCountingStrategy(0);
+  strategy1.topic += 2;
   const [count3, strategy3] = generateRandomCountingStrategy(0);
   strategy3.priority = 50;
+  strategy1.topic += 3;
   const axium = createAxium('axiumStrategyTest', [createCounterConcept()], {logging: true, storeDialog: true});
   const plan = axium.plan('Counting Strategy with Priority Plan',
     [