Constistency, debounce fires most recent action after duration.

ActionStrategy.md

@@ -130,7 +130,7 @@ This was a purposeful design choice, if you find yourself doing such. Known this
 export const createMethod =
   (method: (action: Action) => Action): [Method, Subject<Action>] => {}
 export const createMethodWithConcepts =
-  (method: (action: Action) => Action, concepts$: UnifiedSubject): [Method, Subject<Action>] => {}
+  (method: (action: Action, concepts: Concept[]) => Action, concepts$: UnifiedSubject): [Method, Subject<Action>] => {}
 export const createAsyncMethod =
   (asyncMethod: (controller: ActionController, action: Action) => void): [Method, Subject<Action>] => {}
 export const createAsyncMethodWithConcepts =
@@ -153,7 +153,7 @@ export const createAsyncMethodDebounceWithConcepts =
 * createAsyncMethodWithConcepts - Will also have access to the most recent concepts.
 
 *Note if you are implementing your own debounceAction, pay attention to how these method helpers work. They are handling a passed conclude from debounceAction within their map/switchMap*
-* createMethodDebounce - After the first action, this will filter actions within the duration to be set to the conclude action.
+* createMethodDebounce - Will fire after the set duration with the most recent action, and filter previous actions within the duration to be set to the conclude action.
 * createMethodDebounceWithConcepts - Will filter actions within the duration while providing access to the most recent concepts. 
-* createAsyncMethodDebounce - Will not disengage the initial ActionController, but will allow debounced actions to pass through when filtered as conclude actions. And will fire the first action upon its own conditions are met asynchronously.
+* createAsyncMethodDebounce - Will not disengage the initial ActionController, but will allow debounced actions to pass through when filtered as conclude actions. And will fire the most recent action upon its own conditions are met asynchronously after the set duration.
 * createAsyncMethodDebounceWithConcepts - Filters and then first the first action once conditions are met, and provides access to the most recent concepts.

package.json

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

src/concepts/experiment/experiment.concept.ts

@@ -5,14 +5,16 @@ import { PrincipleFunction } from '../../model/principle';
 export type ExperimentState = {
   actionQue: Action[],
   mock: boolean,
+  id: number
 }
 
 export const experimentName = 'experiment';
 
 export const createExperimentState = (): ExperimentState => {
   return {
     actionQue: [],
-    mock: false
+    mock: false,
+    id: 0,
   };
 };
 

src/concepts/experiment/qualities/asyncIterateIdThenReceiveInMethod.quality copy.ts

@@ -0,0 +1,42 @@
+import { MethodCreator, defaultMethodCreator, defaultReducer } from '../../../model/concept';
+import { Action, prepareActionCreator } from '../../../model/action';
+import { createQuality } from '../../../model/concept';
+import { ExperimentState, experimentName } from '../experiment.concept';
+import { UnifiedSubject } from '../../../model/stagePlanner';
+import { createAsyncMethodWithConcepts, createMethodWithConcepts } from '../../../model/method';
+import { selectState } from '../../../model/selector';
+import { strategySuccess } from '../../../model/actionStrategy';
+import { strategyData_unifyData } from '../../../model/actionStrategyData';
+
+export const experimentAsyncIterateIdThenReceiveInMethodType
+  = 'Experiment asynchronously iterate ID then receive in Method via Concept select';
+
+export const experimentAsyncIterateIdThenReceiveInMethod = prepareActionCreator(experimentAsyncIterateIdThenReceiveInMethodType);
+
+const experimentAsyncIterateIdThenReceiveInMethodCreator: MethodCreator = (concepts$?: UnifiedSubject) =>
+  createAsyncMethodWithConcepts((controller, action, concepts) => {
+    console.log('HIT');
+    setTimeout(() => {
+      const experimentState = selectState<ExperimentState>(concepts, experimentName);
+      if (action.strategy) {
+        const data = strategyData_unifyData<ExperimentState>(action.strategy, {id: experimentState.id});
+        const strategy = strategySuccess(action.strategy, data);
+        console.log('FIRE');
+        controller.fire(strategy);
+      }
+      controller.fire(action);
+    }, 50);
+  }, concepts$ as UnifiedSubject);
+
+function experimentAsyncIterateIdThenReceiveInMethodReducer(state: ExperimentState, _: Action): ExperimentState {
+  return {
+    ...state,
+    id: state.id + 1
+  };
+}
+
+export const experimentAsyncIterateIdThenReceiveInMethodQuality = createQuality(
+  experimentAsyncIterateIdThenReceiveInMethodType,
+  experimentAsyncIterateIdThenReceiveInMethodReducer,
+  experimentAsyncIterateIdThenReceiveInMethodCreator
+);

src/concepts/experiment/qualities/debounceAsyncIterateIdThenReceiveInMethod.quality copy 2.ts

@@ -0,0 +1,52 @@
+import { MethodCreator } from '../../../model/concept';
+import { Action, prepareActionWithPayloadCreator } from '../../../model/action';
+import { createQuality } from '../../../model/concept';
+import { ExperimentState, experimentName } from '../experiment.concept';
+import { UnifiedSubject } from '../../../model/stagePlanner';
+import { createAsyncMethodDebounceWithConcepts } from '../../../model/method';
+import { selectPayload, selectState } from '../../../model/selector';
+import { strategySuccess } from '../../../model/actionStrategy';
+import { strategyData_unifyData } from '../../../model/actionStrategyData';
+
+export type DebounceAsyncIterateIdThenReceiveInMethodPayload = {
+  setId: number;
+}
+export const experimentDebounceAsyncIterateIdThenReceiveInMethodType
+  = 'Experiment asynchronously iterate ID then receive in Method via Concept select';
+export const experimentDebounceAsyncIterateIdThenReceiveInMethod
+  = prepareActionWithPayloadCreator<DebounceAsyncIterateIdThenReceiveInMethodPayload>(
+    experimentDebounceAsyncIterateIdThenReceiveInMethodType
+  );
+
+const experimentDebounceAsyncIterateIdThenReceiveInMethodCreator: MethodCreator = (concepts$?: UnifiedSubject) =>
+  createAsyncMethodDebounceWithConcepts((controller, action, concepts) => {
+    setTimeout(() => {
+      const payload = selectPayload<DebounceAsyncIterateIdThenReceiveInMethodPayload>(action);
+      const experimentState = selectState<ExperimentState>(concepts, experimentName);
+      if (action.strategy) {
+        const data = strategyData_unifyData<ExperimentState & DebounceAsyncIterateIdThenReceiveInMethodPayload>(
+          action.strategy,
+          {
+            id: experimentState.id,
+            setId: payload.setId
+          }
+        );
+        const strategy = strategySuccess(action.strategy, data);
+        controller.fire(strategy);
+      }
+      controller.fire(action);
+    }, 50);
+  }, concepts$ as UnifiedSubject, 500);
+
+function experimentDebounceAsyncIterateIdThenReceiveInMethodReducer(state: ExperimentState, _: Action): ExperimentState {
+  return {
+    ...state,
+    id: state.id + 1
+  };
+}
+
+export const experimentDebounceAsyncIterateIdThenReceiveInMethodQuality = createQuality(
+  experimentDebounceAsyncIterateIdThenReceiveInMethodType,
+  experimentDebounceAsyncIterateIdThenReceiveInMethodReducer,
+  experimentDebounceAsyncIterateIdThenReceiveInMethodCreator
+);

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

@@ -0,0 +1,46 @@
+import { MethodCreator, defaultMethodCreator, defaultReducer } from '../../../model/concept';
+import { Action, prepareActionCreator, prepareActionWithPayloadCreator } from '../../../model/action';
+import { createQuality } from '../../../model/concept';
+import { ExperimentState, experimentName } from '../experiment.concept';
+import { UnifiedSubject } from '../../../model/stagePlanner';
+import { createMethodDebounceWithConcepts, createMethodWithConcepts } from '../../../model/method';
+import { selectPayload, selectState } from '../../../model/selector';
+import { strategySuccess } from '../../../model/actionStrategy';
+import { strategyData_unifyData } from '../../../model/actionStrategyData';
+
+export type DebounceIterateIdThenReceiveInMethodPayload = {
+  setId: number;
+}
+export const experimentDebounceIterateIdThenReceiveInMethodType =
+  'Experiment debounce iterate ID then receive in Method via Concept select';
+
+export const experimentDebounceIterateIdThenReceiveInMethod =
+  prepareActionWithPayloadCreator<DebounceIterateIdThenReceiveInMethodPayload>(experimentDebounceIterateIdThenReceiveInMethodType);
+
+const experimentDebounceIterateIdThenReceiveInMethodCreator: MethodCreator = (concepts$?: UnifiedSubject) =>
+  createMethodDebounceWithConcepts((action, concepts) => {
+    const payload = selectPayload<DebounceIterateIdThenReceiveInMethodPayload>(action);
+    const experimentState = selectState<ExperimentState>(concepts, experimentName);
+    if (action.strategy) {
+      const data = strategyData_unifyData<ExperimentState & DebounceIterateIdThenReceiveInMethodPayload>(action.strategy, {
+        id: experimentState.id,
+        setId: payload.setId
+      });
+      const strategy = strategySuccess(action.strategy, data);
+      return strategy;
+    }
+    return action;
+  }, concepts$ as UnifiedSubject, 500);
+
+function experimentDebounceIterateIdThenReceiveInMethodReducer(state: ExperimentState, _: Action): ExperimentState {
+  return {
+    ...state,
+    id: state.id + 1
+  };
+}
+
+export const experimentDebounceIterateIdThenReceiveInMethodQuality = createQuality(
+  experimentDebounceIterateIdThenReceiveInMethodType,
+  experimentDebounceIterateIdThenReceiveInMethodReducer,
+  experimentDebounceIterateIdThenReceiveInMethodCreator
+);

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

@@ -0,0 +1,37 @@
+import { MethodCreator, defaultMethodCreator, defaultReducer } from '../../../model/concept';
+import { Action, prepareActionCreator } from '../../../model/action';
+import { createQuality } from '../../../model/concept';
+import { ExperimentState, experimentName } from '../experiment.concept';
+import { UnifiedSubject } from '../../../model/stagePlanner';
+import { createMethodWithConcepts } from '../../../model/method';
+import { selectState } from '../../../model/selector';
+import { strategySuccess } from '../../../model/actionStrategy';
+import { strategyData_unifyData } from '../../../model/actionStrategyData';
+
+export const experimentIterateIdThenReceiveInMethodType = 'Experiment iterate ID then receive in Method via Concept select';
+
+export const experimentIterateIdThenReceiveInMethod = prepareActionCreator(experimentIterateIdThenReceiveInMethodType);
+
+const experimentIterateIdThenReceiveInMethodCreator: MethodCreator = (concepts$?: UnifiedSubject) =>
+  createMethodWithConcepts((action, concepts) => {
+    const experimentState = selectState<ExperimentState>(concepts, experimentName);
+    if (action.strategy) {
+      const data = strategyData_unifyData<ExperimentState>(action.strategy, {id: experimentState.id});
+      const strategy = strategySuccess(action.strategy, data);
+      return strategy;
+    }
+    return action;
+  }, concepts$ as UnifiedSubject);
+
+function experimentIterateIdThenReceiveInMethodReducer(state: ExperimentState, _: Action): ExperimentState {
+  return {
+    ...state,
+    id: state.id + 1
+  };
+}
+
+export const experimentIterateIdThenReceiveInMethodQuality = createQuality(
+  experimentIterateIdThenReceiveInMethodType,
+  experimentIterateIdThenReceiveInMethodReducer,
+  experimentIterateIdThenReceiveInMethodCreator
+);

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

@@ -0,0 +1,17 @@
+import { ActionStrategy, ActionStrategyParameters, createActionNode, createStrategy } from '../../../model/actionStrategy';
+import { experimentAsyncIterateIdThenReceiveInMethod } from '../qualities/asyncIterateIdThenReceiveInMethod.quality copy';
+
+export const asyncIterateIdThenAddToDataTopic = 'Async iterate experiment ID then add to strategy data';
+export function asyncIterateIdThenAddToData(): ActionStrategy {
+  const stepOne = createActionNode(experimentAsyncIterateIdThenReceiveInMethod(), {
+    successNode: null,
+    failureNode: null,
+  });
+
+  const params: ActionStrategyParameters = {
+    topic: asyncIterateIdThenAddToDataTopic,
+    initialNode: stepOne,
+  };
+
+  return createStrategy(params);
+}

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

@@ -0,0 +1,17 @@
+import { ActionStrategy, ActionStrategyParameters, createActionNode, createStrategy } from '../../../model/actionStrategy';
+import { experimentDebounceAsyncIterateIdThenReceiveInMethod } from '../qualities/debounceAsyncIterateIdThenReceiveInMethod.quality copy 2';
+
+export const debounceAsyncIterateIdThenAddToDataTopic = 'Debounce async iterate experiment ID then add to strategy data';
+export function debounceAsyncIterateIdThenAddToData(setId: number): ActionStrategy {
+  const stepOne = createActionNode(experimentDebounceAsyncIterateIdThenReceiveInMethod({setId}), {
+    successNode: null,
+    failureNode: null,
+  });
+
+  const params: ActionStrategyParameters = {
+    topic: debounceAsyncIterateIdThenAddToDataTopic,
+    initialNode: stepOne,
+  };
+
+  return createStrategy(params);
+}

src/concepts/experiment/strategies/debounceIterateIdThenAddToData.strategy copy.ts

@@ -0,0 +1,17 @@
+import { ActionStrategy, ActionStrategyParameters, createActionNode, createStrategy } from '../../../model/actionStrategy';
+import { experimentDebounceIterateIdThenReceiveInMethod } from '../qualities/debounceIterateIdThenReceiveInMethod.quality';
+
+export const debounceIterateIdThenAddToDataTopic = 'Debounce iterate experiment ID then add to strategy data';
+export function debounceIterateIdThenAddToData(setId: number): ActionStrategy {
+  const stepOne = createActionNode(experimentDebounceIterateIdThenReceiveInMethod({setId}), {
+    successNode: null,
+    failureNode: null,
+  });
+
+  const params: ActionStrategyParameters = {
+    topic: debounceIterateIdThenAddToDataTopic,
+    initialNode: stepOne,
+  };
+
+  return createStrategy(params);
+}

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

@@ -0,0 +1,17 @@
+import { ActionStrategy, ActionStrategyParameters, createActionNode, createStrategy } from '../../../model/actionStrategy';
+import { experimentIterateIdThenReceiveInMethod } from '../qualities/iterateIdThenReceiveInMethod.quality';
+
+export const iterateIdThenAddToDataTopic = 'Iterate experiment ID then add to strategy data';
+export function iterateIdThenAddToData(): ActionStrategy {
+  const stepOne = createActionNode(experimentIterateIdThenReceiveInMethod(), {
+    successNode: null,
+    failureNode: null,
+  });
+
+  const params: ActionStrategyParameters = {
+    topic: iterateIdThenAddToDataTopic,
+    initialNode: stepOne,
+  };
+
+  return createStrategy(params);
+}

src/model/actionStrategy.ts

@@ -240,6 +240,7 @@ export const strategySuccess = (_strategy: ActionStrategy, data?: Record<string,
     conclude.action.strategy = {
       ...strategy,
       currentNode: conclude,
+      data: data ? data : strategy.data
     };
     return conclude.action;
   }
@@ -250,7 +251,7 @@ export const strategySuccess = (_strategy: ActionStrategy, data?: Record<string,
  * If no failureNode is found, will return EndOfActionStrategy instead.
  * @param data - OPTIONAL, if used will override the ActionStrategy's payload
  */
-export function strategyFailed(_strategy: ActionStrategy, data?: unknown) {
+export function strategyFailed(_strategy: ActionStrategy, data?: Record<string, unknown>) {
   const strategy = {..._strategy};
   let nextAction: Action;
   const actionListEntry = createSentence(
@@ -310,6 +311,7 @@ export function strategyFailed(_strategy: ActionStrategy, data?: unknown) {
     conclude.action.strategy = {
       ...strategy,
       currentNode: conclude,
+      data: data ? data : strategy.data
     };
     return conclude.action;
   }
@@ -388,6 +390,7 @@ export const strategyDecide = (
   conclude.action.strategy = {
     ...strategy,
     currentNode: conclude,
+    data: data ? data : strategy.data
   };
   return conclude.action;
 };

src/model/actionStrategyData.ts

@@ -59,13 +59,14 @@ export const strategyData_select = <T>(strategy: ActionStrategy): T | undefined
   }
 };
 
-export const strategyData_unifyData = (strategy: ActionStrategy, data: Record<string,unknown>): Record<string,unknown> => {
-  if (strategy.data) {
-    return {
-      ...strategy.data,
-      ...data
-    };
-  } else {
-    return {...data};
-  }
-};
+export const strategyData_unifyData =
+  <T extends Record<string, unknown>>(strategy: ActionStrategy, data: Record<string,unknown> | T): Record<string,unknown> => {
+    if (strategy.data) {
+      return {
+        ...strategy.data,
+        ...data
+      };
+    } else {
+      return {...data};
+    }
+  };

src/model/method.ts

@@ -38,12 +38,12 @@ export const createMethod =
     return [defaultMethod, defaultSubject];
   };
 export const createMethodWithConcepts =
-  (method: (action: Action) => Action, concepts$: UnifiedSubject): [Method, Subject<Action>] => {
+  (methodWithConcepts: (action: Action, concepts: Concept[]) => Action, concepts$: UnifiedSubject): [Method, Subject<Action>] => {
     const defaultSubject = new Subject<Action>();
     const defaultMethod: Method = defaultSubject.pipe(
       withLatestFrom(concepts$ as UnifiedSubject),
       map(([act, concepts] : [Action, Concept[]]) => {
-        const methodAction = method(act);
+        const methodAction = methodWithConcepts(act, concepts);
         if (methodAction.strategy) {
           return methodAction;
         }
@@ -71,10 +71,9 @@ export const createAsyncMethodWithConcepts =
     const defaultSubject = new Subject<Action>();
     const defaultMethod: Method = defaultSubject.pipe(
       withLatestFrom(concepts$ as UnifiedSubject),
-      switchMap(([act, concepts] : [Action, Concept[]]) =>
-        createActionController$(act, (controller: ActionController, action: Action) => {
-          asyncMethodWithConcepts(controller, action, concepts);
-        })),
+      switchMap(([act, concepts] : [Action, Concept[]]) => createActionController$(act, (controller: ActionController, action: Action) => {
+        asyncMethodWithConcepts(controller, action, concepts);
+      })),
     );
     return [defaultMethod, defaultSubject];
   };