Merge pull request #82 from Phuire-Research/UI

Clean up

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

@@ -1,5 +1,5 @@
 import { Subject } from 'rxjs';
-import { createStrategy, ActionNode, ActionStrategy, ActionStrategyParameters, createActionNode } from '../../../model/actionStrategy';
+import { createStrategy, ActionStrategy, ActionStrategyParameters, createActionNode } from '../../../model/actionStrategy';
 import { Concept } from '../../../model/concept';
 import { Action, getSemaphore} from '../../../model/action';
 import { axiumAddConceptFromQue, axiumAddConceptFromQueType } from '../qualities/addConceptsFromQue.quality';
@@ -12,15 +12,15 @@ import { axiumName } from '../axium.concept';
 // Step One to Add Concepts to Axium
 export const addConceptsToAddQueThenBlockTopic = 'Add Concepts to add que then set Axium Mode to Blocking';
 export function addConceptsToAddQueThenBlockStrategy(concepts: Concept[], newConcepts: Concept[]) {
-  const stepTwo: ActionNode = createActionNode(axiumAppendConceptsToAddQue({concepts: newConcepts}),{
+  const stepTwo = createActionNode(axiumAppendConceptsToAddQue({concepts: newConcepts}),{
     successNode: null,
     successNotes: {
       preposition: 'Then Safely'
     },
     failureNode: null,
     semaphore: getSemaphore(concepts, axiumName, axiumAppendConceptsToAddQueType),
   });
-  const stepOne: ActionNode = createActionNode(axiumSetBlockingMode({concepts}), {
+  const stepOne = createActionNode(axiumSetBlockingMode({concepts}), {
     successNode: stepTwo,
     successNotes: {
       preposition: 'Immediately'
@@ -42,7 +42,7 @@ export function addConceptsFromQueThenUnblockStrategy(action$: Subject<Action>,
   const setDefaultModeSemaphore = getSemaphore(conceptualSet, axiumName, axiumSetDefaultModeType);
   const openSemaphore = getSemaphore(conceptualSet, axiumName, axiumOpenType);
 
-  const stepThree: ActionNode = createActionNode(axiumOpen(true), {
+  const stepThree = createActionNode(axiumOpen(true), {
     successNode: null,
     successNotes: {
       preposition: 'Reinstate',
@@ -51,15 +51,15 @@ export function addConceptsFromQueThenUnblockStrategy(action$: Subject<Action>,
     failureNode: null,
     semaphore: openSemaphore,
   });
-  const stepTwo: ActionNode = createActionNode(axiumSetDefaultMode({concepts: conceptualSet}), {
+  const stepTwo = createActionNode(axiumSetDefaultMode({concepts: conceptualSet}), {
     semaphore: setDefaultModeSemaphore,
     successNode: stepThree,
     successNotes: {
       preposition: 'Then'
     },
     failureNode: null,
   });
-  const stepOne: ActionNode = createActionNode(axiumAddConceptFromQue(),{
+  const stepOne = createActionNode(axiumAddConceptFromQue(),{
     semaphore: addConceptsFromQueSemaphore,
     successNode: stepTwo,
     successNotes: {

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

@@ -1,4 +1,4 @@
-import { createStrategy, ActionNode, ActionStrategy, ActionStrategyParameters, createActionNode } from '../../../model/actionStrategy';
+import { createStrategy, ActionStrategy, ActionStrategyParameters, createActionNode } from '../../../model/actionStrategy';
 import { Concept } from '../../../model/concept';
 import { getSemaphore } from '../../../model/action';
 import { axiumRemoveConceptsViaQue, axiumRemoveConceptsViaQueType } from '../qualities/removeConceptsViaQue.quality';
@@ -13,12 +13,12 @@ export function addConceptsToRemovalQueThenBlockStrategy(concepts: Concept[], ta
   const setBlockingModeSemaphore = getSemaphore(concepts, axiumName, axiumSetBlockingModeType);
   const appendConceptsToRemoveQueSemaphore = getSemaphore(concepts, axiumName, axiumAppendConceptsToRemoveQueType);
 
-  const stepTwo: ActionNode = createActionNode(axiumAppendConceptsToRemoveQue({concepts: targetConcepts}), {
+  const stepTwo = createActionNode(axiumAppendConceptsToRemoveQue({concepts: targetConcepts}), {
     semaphore: appendConceptsToRemoveQueSemaphore,
     successNode: null,
     failureNode: null,
   });
-  const stepOne: ActionNode = createActionNode(axiumSetBlockingMode({concepts}), {
+  const stepOne = createActionNode(axiumSetBlockingMode({concepts}), {
     semaphore: setBlockingModeSemaphore,
     successNode: stepTwo,
     failureNode: null,
@@ -36,7 +36,7 @@ export function removeConceptsViaQueThenUnblockStrategy(concepts: Concept[]): Ac
   const setDefaultModeSemaphore = getSemaphore(concepts, axiumName, axiumSetDefaultModeType);
   const openSemaphore = getSemaphore(concepts, axiumName, axiumOpenType);
 
-  const stepThree: ActionNode = createActionNode(axiumOpen(true), {
+  const stepThree = createActionNode(axiumOpen(true), {
     semaphore: openSemaphore,
     successNode: null,
     successNotes: {
@@ -45,15 +45,15 @@ export function removeConceptsViaQueThenUnblockStrategy(concepts: Concept[]): Ac
     },
     failureNode: null,
   });
-  const stepTwo: ActionNode = createActionNode(axiumSetDefaultMode({concepts}), {
+  const stepTwo = createActionNode(axiumSetDefaultMode({concepts}), {
     semaphore: setDefaultModeSemaphore,
     successNode: stepThree,
     successNotes: {
       preposition: 'Then'
     },
     failureNode: null,
   });
-  const stepOne: ActionNode = createActionNode(axiumRemoveConceptsViaQue(), {
+  const stepOne = createActionNode(axiumRemoveConceptsViaQue(), {
     semaphore: removeConceptsViaQueSemaphore,
     successNode: stepTwo,
     successNotes: {

src/concepts/counter/strategies/counting.strategy.ts

@@ -1,4 +1,4 @@
-import { createStrategy, ActionNode, ActionStrategy, ActionStrategyParameters, createActionNode } from '../../../model/actionStrategy';
+import { createStrategy, ActionStrategy, ActionStrategyParameters, createActionNode } from '../../../model/actionStrategy';
 import { Concept} from '../../../model/concept';
 import { getSemaphore } from '../../../model/action';
 import { counterAdd, counterAddType } from '../qualities/add.quality';
@@ -7,39 +7,39 @@ import { counterName } from '../counter.concept';
 
 export const countingTopic = 'Counting Strategy';
 export function countingStrategy(): ActionStrategy {
-  const stepFive: ActionNode = createActionNode(counterSubtract(), {
+  const stepFive = createActionNode(counterSubtract(), {
     successNode: null,
     successNotes: {
       preposition: 'and finally',
       denoter: 'One.',
     },
     failureNode: null,
   });
-  const stepFour: ActionNode = createActionNode(counterAdd(), {
+  const stepFour = createActionNode(counterAdd(), {
     successNode: stepFive,
     successNotes: {
       preposition: '',
       denoter: 'One;',
     },
     failureNode: null,
   });
-  const stepThree: ActionNode = createActionNode(counterAdd(), {
+  const stepThree = createActionNode(counterAdd(), {
     successNode: stepFour,
     successNotes: {
       preposition: '',
       denoter: 'One;',
     },
     failureNode: null,
   });
-  const stepTwo: ActionNode = createActionNode(counterSubtract(), {
+  const stepTwo = createActionNode(counterSubtract(), {
     successNode: stepThree,
     successNotes: {
       preposition: '',
       denoter: 'One;',
     },
     failureNode: null,
   });
-  const stepOne: ActionNode = createActionNode(counterAdd(), {
+  const stepOne = createActionNode(counterAdd(), {
     successNode: stepTwo,
     successNotes: {
       preposition: '',
@@ -60,7 +60,7 @@ export const primedCountingTopic = 'Counting Strategy with Primed Actions';
 export function primedCountingStrategy(concepts: Concept[]): ActionStrategy {
   const addSemaphore = getSemaphore(concepts, counterName, counterAddType);
   const subtractSemaphore = getSemaphore(concepts, counterName, counterSubtractType);
-  const stepFour: ActionNode = createActionNode(counterAdd(), {
+  const stepFour = createActionNode(counterAdd(), {
     semaphore: addSemaphore,
     successNode: null,
     successNotes: {
@@ -69,7 +69,7 @@ export function primedCountingStrategy(concepts: Concept[]): ActionStrategy {
     },
     failureNode: null,
   });
-  const stepThree: ActionNode = createActionNode(counterAdd(), {
+  const stepThree = createActionNode(counterAdd(), {
     semaphore: addSemaphore,
     successNode: stepFour,
     successNotes: {
@@ -78,7 +78,7 @@ export function primedCountingStrategy(concepts: Concept[]): ActionStrategy {
     },
     failureNode: null,
   });
-  const stepTwo: ActionNode = createActionNode(counterSubtract(), {
+  const stepTwo = createActionNode(counterSubtract(), {
     semaphore: subtractSemaphore,
     successNode: stepThree,
     successNotes: {
@@ -87,7 +87,7 @@ export function primedCountingStrategy(concepts: Concept[]): ActionStrategy {
     },
     failureNode: null,
   });
-  const stepOne: ActionNode = createActionNode(counterAdd(), {
+  const stepOne = createActionNode(counterAdd(), {
     semaphore: subtractSemaphore,
     successNode: stepTwo,
     successNotes: {

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

@@ -1,4 +1,4 @@
-import { createStrategy, ActionNode, ActionStrategy, ActionStrategyParameters, createActionNode } from '../../../model/actionStrategy';
+import { createStrategy, ActionStrategy, ActionStrategyParameters, createActionNode } from '../../../model/actionStrategy';
 import { Concept} from '../../../model/concept';
 import { getSemaphore } from '../../../model/action';
 import { counterAdd, counterAddType } from '../../counter/qualities/add.quality';

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

@@ -1,11 +1,11 @@
-import { ActionNode, ActionStrategy, ActionStrategyParameters, createActionNode, createStrategy, puntStrategy } from '../../../model/actionStrategy';
+import { ActionStrategy, ActionStrategyParameters, createActionNode, createStrategy, puntStrategy } from '../../../model/actionStrategy';
 import { counterSelectCount } from '../../counter/counter.selector';
 import { experimentCheckInStrategy } from '../qualities/checkInStrategy.quality';
 import { experimentCountingStrategy } from './experimentCounting.strategy';
 
 export const puntCountingStrategyTopic = 'This will Punt the Counting Strategy into the Experiment\'s Action Que';
 export function puntCountingStrategy(): ActionStrategy {
-  const stepOne: ActionNode = createActionNode(experimentCheckInStrategy(), {
+  const stepOne = createActionNode(experimentCheckInStrategy(), {
     successNode: null,
     failureNode: null,
     keyedSelectors: [counterSelectCount]

src/concepts/ownership/strategies/setOwnerShipMode.strategy.ts

@@ -1,4 +1,4 @@
-import { createStrategy, ActionNode, ActionStrategy, ActionStrategyParameters, createActionNode } from '../../../model/actionStrategy';
+import { createStrategy, ActionStrategy, ActionStrategyParameters, createActionNode } from '../../../model/actionStrategy';
 import { Concept } from '../../../model/concept';
 import { getSemaphore } from '../../../model/action';
 import { ownershipInitializeOwnership, ownershipInitializeOwnershipType } from '../qualities/initializeOwnership.quality';
@@ -17,15 +17,15 @@ export function setOwnershipModeStrategy(concepts: Concept[], modeName: string):
     }
   });
 
-  const stepTwo: ActionNode = createActionNode(ownershipInitializeOwnership(), {
+  const stepTwo = createActionNode(ownershipInitializeOwnership(), {
     semaphore: initializeOwnershipSemaphore,
     successNode: null,
     successNotes: {
       preposition: 'Set',
     },
     failureNode: null,
   });
-  const stepOne: ActionNode = createActionNode(axiumSetMode({ modeIndex: ownershipModeIndex, modeName }), {
+  const stepOne = createActionNode(axiumSetMode({ modeIndex: ownershipModeIndex, modeName }), {
     semaphore: setModeSemaphore,
     successNode: stepTwo,
     successNotes: {