Merge pull request #138 from Phuire-Research/UI

UI

package.json

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

src/concepts/axium/qualities/addConceptsFromQue.quality.ts

@@ -1,5 +1,5 @@
 import { Observable, Subject, Subscriber, catchError } from 'rxjs';
-import { defaultMethodCreator } from '../../../model/concept';
+import { defaultMethodCreator, qualityToString } from '../../../model/concept';
 import { AxiumState } from '../axium.concept';
 import { Action, ActionType, prepareActionCreator } from '../../../model/action';
 import { createQuality } from '../../../model/concept';
@@ -22,6 +22,7 @@ function addConceptsFromQueReducer(state: AxiumState, action: Action) {
             }
             return caught;
           }));
+        quality.toString = qualityToString(quality);
         const methodSub = quality.method.subscribe((act: Action) => {
           const action$ = state.action$ as Subject<Action>;
           blockingMethodSubscription(action$, act);

src/index.ts

@@ -52,7 +52,9 @@ export {
   isConceptLoaded,
   areConceptsLoaded,
   unifyConcepts,
-  forEachConcept
+  forEachConcept,
+  conceptToString,
+  conceptsToString
 } from './model/concept';
 export type {
   Concept,

src/model/axium.ts

@@ -7,14 +7,13 @@ import {
 } from 'rxjs';
 import { Action, createCacheSemaphores } from './action';
 import { strategyBegin } from './actionStrategy';
-import { Concept, Concepts, Mode, forEachConcept } from './concept';
+import { Concept, Concepts, Method, Mode, forEachConcept, qualityToString } from './concept';
 import {
   createAxiumConcept,
   AxiumState,
   initializationStrategy,
   axiumName,
 } from '../concepts/axium/axium.concept';
-import { axiumClose } from '../concepts/axium/qualities/close.quality';
 import {
   axiumAppendActionListToDialog,
 } from '../concepts/axium/qualities/appendActionListToDialog.quality';
@@ -82,16 +81,15 @@ export function createAxium(name: string, initialConcepts: Concept[], logging?:
   forEachConcept(concepts, ((concept, semaphore) => {
     concept.qualities.forEach(quality => {
       if (quality.methodCreator) {
-        const [method, subject] = quality.methodCreator(axiumState.concepts$, semaphore);
-        quality.method = method;
-        quality.subject = subject;
+        [quality.method, quality.subject] = quality.methodCreator(axiumState.concepts$, semaphore);
         quality.method.pipe(
           catchError((err: unknown, caught: Observable<Action>) => {
             if (axiumState.logging) {
               console.error('METHOD ERROR', err);
             }
             return caught;
           }));
+        quality.toString = qualityToString(quality);
         const methodSub = quality.method.subscribe((action: Action) => {
           blockingMethodSubscription(axiumState.action$, action);
         }) as Subscriber<Action>;

src/model/concept.ts

@@ -25,6 +25,7 @@ export type MethodCreator = (concept$?: UnifiedSubject, semaphore?: number) => [
 export type Quality = {
   actionType: ActionType;
   reducer: Reducer;
+  toString: () => string;
   methodCreator?: MethodCreator;
   method?: Method;
   subject?: Subject<Action>;
@@ -241,6 +242,7 @@ export function createQuality(
 export function defaultReducer(state: unknown, _: Action) {
   return state;
 }
+defaultReducer.toString = () => ('Default Reducer');
 
 export const defaultMethodCreator: MethodCreator = () : [Method, Subject<Action>] =>  {
   const defaultSubject = new Subject<Action>();
@@ -255,6 +257,8 @@ export const defaultMethodCreator: MethodCreator = () : [Method, Subject<Action>
       };
     }),
   );
+
+  defaultMethod.toString = () => ('Default Method');
   return [defaultMethod, defaultSubject];
 };
 
@@ -296,3 +300,57 @@ export const forEachConcept = (concepts: Concepts, each: (concept: Concept, sema
     each(concepts[index], index);
   }
 };
+
+const stateToString = (state: Record<string, unknown>): string => {
+  let final = '{\n';
+  const keys = Object.keys(state);
+  for (const key of keys) {
+    let input = '';
+    try {
+      input += `${key}: ${JSON.stringify(state[key])},\n`;
+    } catch (err) {
+      input = `${key}: CIRCULAR,\n`;
+    }
+    final += input;
+  }
+  final += '}';
+  return final;
+};
+
+export const conceptToString = (concept: Concept): string => {
+  let output = '';
+  output += `{\nname: ${concept.name},`;
+  if (concept.unified.length > 0) {
+    output += `\nunified: ${concept.unified},`;
+  }
+  output += `\nqualities: [ ${concept.qualities.toString()}\n],`;
+  output += `\nstate: ${stateToString(concept.state)}, `;
+  if (concept.principles) {
+    output += `\nprinciples: [ ${concept.principles.map(p => p.toString()).join(',')} ]`;
+  }
+  if (concept.mode) {
+    output += `\nmode: [ ${concept.mode.map(m => m.toString()).join(',')} ]`;
+  }
+  if (concept.meta) {
+    output += `\nmeta: ${JSON.stringify(concept.meta)}`;
+  }
+  output += '\n}';
+  return output;
+};
+
+export const conceptsToString = (concepts: Concepts): string => {
+  const conceptStringArray: string[] = [];
+  forEachConcept(concepts, (concept) => {
+    conceptStringArray.push(conceptToString(concept));
+  });
+  conceptStringArray.push(']');
+  return '[\n' + conceptStringArray.join(',\n');
+};
+
+export const qualityToString = (quality: Quality) => () => {
+  const actionType = quality.actionType;
+  const r = quality.reducer.toString();
+  const reducer = r === 'Default Reducer' ? r : 'Reducer';
+  const method = quality.method?.toString();
+  return (`\n{\nactionType: ${actionType},\nreducer: ${reducer},\nmethod: ${method}\n}`);
+};

src/model/method.ts

@@ -19,7 +19,7 @@ type Action = {
     expiration: number;
     axium?: string;
 };
-type Method = Observable<Action>;
+type Method = Observable<Action> & {toString: () => string};
 
 export const createMethod =
   (method: (action: Action) => Action): [Method, Subject<Action>] => {
@@ -37,6 +37,7 @@ export const createMethod =
         };
       }),
     );
+    defaultMethod.toString = () => ('Method');
     return [defaultMethod, defaultSubject];
   };
 export const createMethodWithState =
@@ -61,6 +62,7 @@ export const createMethodWithState =
         };
       }),
     );
+    defaultMethod.toString = () => ('Method with State');
     return [defaultMethod, defaultSubject];
   };
 export const createAsyncMethod =
@@ -71,6 +73,7 @@ export const createAsyncMethod =
         asyncMethod(controller, action);
       })),
     );
+    defaultMethod.toString = () => ('Async Method');
     return [defaultMethod, defaultSubject];
   };
 export const createAsyncMethodWithState =
@@ -88,6 +91,7 @@ export const createAsyncMethodWithState =
         asyncMethodWithState(controller, action, state);
       })),
     );
+    defaultMethod.toString = () => ('Async Method with State');
     return [defaultMethod, defaultSubject];
   };
 export const createMethodDebounce =
@@ -112,6 +116,7 @@ export const createMethodDebounce =
         }
       }),
     );
+    defaultMethod.toString = () => ('Debounce Method');
     return [defaultMethod, defaultSubject];
   };
 export const createMethodDebounceWithState =
@@ -139,6 +144,7 @@ export const createMethodDebounceWithState =
         }
       }),
     );
+    defaultMethod.toString = () => ('Debounce Method with State');
     return [defaultMethod, defaultSubject];
   };
 export const createAsyncMethodDebounce =
@@ -152,6 +158,7 @@ export const createAsyncMethodDebounce =
         });
       }),
     );
+    defaultMethod.toString = () => ('Async Debounce Method');
     return [defaultMethod, defaultSubject];
   };
 export const createAsyncMethodDebounceWithState =
@@ -168,6 +175,7 @@ export const createAsyncMethodDebounceWithState =
         });
       })
     );
+    defaultMethod.toString = () => ('Async Debounce Method with State');
     return [defaultMethod, defaultSubject];
   };
 export const createMethodThrottle =
@@ -192,6 +200,7 @@ export const createMethodThrottle =
         }
       }),
     );
+    defaultMethod.toString = () => ('Throttle Method');
     return [defaultMethod, defaultSubject];
   };
 export const createMethodThrottleWithState =
@@ -219,6 +228,7 @@ export const createMethodThrottleWithState =
         }
       }),
     );
+    defaultMethod.toString = () => ('Throttle Method with State');
     return [defaultMethod, defaultSubject];
   };
 export const createAsyncMethodThrottle =
@@ -232,6 +242,7 @@ export const createAsyncMethodThrottle =
         });
       }),
     );
+    defaultMethod.toString = () => ('Async Throttle Method');
     return [defaultMethod, defaultSubject];
   };
 export const createAsyncMethodThrottleWithState =
@@ -248,5 +259,6 @@ export const createAsyncMethodThrottleWithState =
         });
       })
     );
+    defaultMethod.toString = () => ('Async Throttle Method with State');
     return [defaultMethod, defaultSubject];
   };

src/test/conceptToString.test.ts

@@ -0,0 +1,19 @@
+import { createAxium } from '../model/axium';
+import { strategyBegin } from '../model/actionStrategy';
+import { selectState } from '../model/selector';
+import { Counter, createCounterConcept, countingStrategy, counterName } from '../concepts/counter/counter.concept';
+import { AxiumState } from '../concepts/axium/axium.concept';
+import { countingTopic } from '../concepts/counter/strategies/counting.strategy';
+import { conceptToString, conceptsToString } from '../model/concept';
+
+test('Axium Counting Strategy Test', (done) => {
+  const axium = createAxium('axiumStrategyTest', [createCounterConcept()], true, true);
+  const sub = axium.subscribe(concepts => {
+    console.log('CONCEPTS:', conceptsToString(concepts));
+    expect(true).toBe(true);
+    sub.unsubscribe();
+    setTimeout(() => {
+      done();
+    }, 500);
+  });
+});