Merge pull request #100 from Phuire-Research/UI

UI

ActionStrategy.md

@@ -6,6 +6,11 @@ The staked effect of this data structure is one that is capable of mapping the i
 
 As the original pursuit of this data structure was to utilize the data parameter to formalize a transformation of said data over a period of steps. To map the exact transformation of data through an application, versus a series of factories. This chain like pattern of design is represented as a separate concept within this framework. As the framework is designed to be wholly responsible for itself. As the main issue would be the change of data that the chained behavior may be dependent upon. To allow for that data to transformation across any number of nodes on a graph, we introduced the spatial ownership design pattern. Where the final destination for such could be the original axium, the client's screen, or even the database of some server. This is a formalization of a greater than the sums approach to programming by way of composition, decomposition, and recomposition of sets of concepts, contained within some axium that interacts with other axiums.
 
+### How STRX allows ActionStrategies to be a Data Oriented Format for Graph Computation.
+Since STRX uses semaphores over strings types to formalize its own inner workings. The main functionality of strings throughout this system are for readability and being able to isolate some additional functionality at run time. Due to this approach, the net run time of a "Axium" is just a series of entities(actions/state/concept), arrays (staged plans), trees(action strategy), and graphs(staged plans + punted/sequence strategies). That can be made numerically pure with a compilation process to set the semaphores ahead of time. Therefore this system is functionally just a graph programming framework that uses strings for user comprehension, and such can be stripped.
+
+The only blocker in the scope of this current implementation, is that we find faulty actions, plans, and the concluding strategies via a type comparison. This can be further extrapolated away, but would save that work for a low level programming language. As the choice of Typescript in this project was due to familiarity and as the fastest path towards creating a MVP. This is mainly as a note for later as graph computation hits parity.
+
 #### The Exponential/Higher Order Complexity of a Binary Tree
 ![The Exponential Higher Order Complexity of a Binary Tree](https://github.com/Phuire-Research/STRX/blob/main/TreeExponetial.png?raw=true)
 The Reality of what the ActionStrategy Pattern represents despite deceiving simplicity, is the direct mapping of higher orders of logic. As if we examine the increasing levels of complexity of any given ActionStrategy. The complexity by default is squared or doubling. As each step in combination with its dynamic nature has the possibility of failure. If the axium has the ownership concept loaded and a value of state has a lock, or via some other test that can be supplied within the governing method. It is interesting to Note how this relationship is obfuscated via mathematics, but plain in conceptual logic. That of a mechanical greater than the sums relationship. "As if you attempt to square one, you get one. And if you square the number of branches, you get four, but at the one that is the head of the tree. And represents a doubling, but likewise ignores the possibility of additional branches beyond the two."

src/test/actionController.test.ts

@@ -1,20 +1,7 @@
 import { ActionController, createActionController$ } from '../model/actionController';
 import { axiumBadActionType  } from '../concepts/axium/qualities/badAction.quality';
 import { axiumLog, axiumLogType } from '../concepts/axium/qualities/log.quality';
-import { ExperimentState, createExperimentConcept, createExperimentState, experimentName } from '../concepts/experiment/experiment.concept';
-import { timerEmitActionQuality } from '../concepts/experiment/qualities/timerEmitAction.quality';
-import { mockToTrueQuality } from '../concepts/experiment/qualities/mockTrue.quality';
-import { createAxium } from '../model/axium';
-import { timedMockToTrue } from '../concepts/experiment/strategies/timedMockToTrue.strategy';
-import { createActionNode, strategyBegin } from '../model/actionStrategy';
-import { selectSlice, selectState } from '../model/selector';
-import { axiumConcludeType } from '../concepts/axium/qualities/conclude.quality';
-import { timerEmitActionWithConceptsQuality } from '../concepts/experiment/qualities/timerEmitActionWithConcepts.quality';
-import {
-  timedMockToTrueWithConcepts,
-  timedMockToTrueWithConceptsTopic
-} from '../concepts/experiment/strategies/timedMockToTrueWithConcepts.strategy';
-import { axiumSelectLastStrategy, axiumSelectLastStrategyData } from '../concepts/axium/axium.selector';
+import { createActionNode } from '../model/actionStrategy';
 
 test('ActionController Expired Test', (done) => {
   const act = axiumLog(undefined, 200);
@@ -45,22 +32,3 @@ test('ActionController createActionController$ Test', (done) => {
     done();
   });
 });
-
-test('ActionController createActionController$ Mock Strategy', (done) => {
-  const act = axiumLog(undefined, 200);
-  act.strategy = {
-    topic: 'Mock Strategy',
-    actionList: [''],
-    currentNode: createActionNode(act, {
-      successNode: null,
-      failureNode: null
-    })
-  };
-  const cont = createActionController$(act, (controller, action) => {
-    controller.fire(action);
-  });
-  cont.subscribe(action => {
-    expect(action.type).toBe(axiumLogType);
-    done();
-  });
-});

src/test/debounceMethods.test.ts

@@ -12,7 +12,7 @@ import { selectState } from '../model/selector';
 test('Debounce method prevent excess count', (done) => {
   const experiment = createExperimentConcept(createExperimentState(), [debounceNextActionNodeQuality]);
   const axium = createAxium('Experiment async method creator with Concepts', [createCounterConcept(), experiment]);
-  const plan = axium.stage('timed mock to true', [
+  const plan = axium.stage('Experiment debounce add one', [
     (_, dispatch) => {
       dispatch(strategyBegin(experimentDebounceAddOneStrategy()), {
         iterateStage: true
@@ -43,8 +43,8 @@ test('Debounce method prevent excess count', (done) => {
 
 test('Async debounce method prevent excess count', (done) => {
   const experiment = createExperimentConcept(createExperimentState(), [asyncDebounceNextActionNodeQuality]);
-  const axium = createAxium('Experiment async method creator with Concepts', [createCounterConcept(), experiment]);
-  const plan = axium.stage('timed mock to true', [
+  const axium = createAxium('Experiment async debounce', [createCounterConcept(), experiment]);
+  const plan = axium.stage('Experiment async debounce add one', [
     (_, dispatch) => {
       dispatch(strategyBegin(experimentAsyncDebounceAddOneStrategy()), {
         iterateStage: true
@@ -71,7 +71,7 @@ test('Async debounce method prevent excess count', (done) => {
     }
   ]);
   setTimeout(() => {
-    const secondPlan = axium.stage('second timed mock', [
+    const secondPlan = axium.stage('Second experiment async debounce add one', [
       (_, dispatch) => {
         dispatch(strategyBegin(experimentAsyncDebounceAddOneStrategy()), {
           iterateStage: true