@pihanga2/core 0.3.3 → 0.3.5

package/src/reducer.ts

@@ -1,4 +1,4 @@
-import { Action, Reducer } from "@reduxjs/toolkit"
+import {Action, Reducer} from "@reduxjs/toolkit";
 import {
   DispatchF,
   PiReducer,
@@ -9,110 +9,137 @@ import {
   ReduceOnceF,
   ReduxAction,
   ReduxState,
-} from "./types"
-import { produce } from "immer"
-import { RegisterCardState, UPDATE_STATE_ACTION } from "./card"
-import StackTrace from "stacktrace-js"
-import { getLogger } from "./logger"
-import { Dispatch } from "react"
-import { currentRoute } from "./router"
+} from "./types";
+import {produce} from "immer";
+import {RegisterCardState, UPDATE_STATE_ACTION} from "./card";
+import StackTrace from "stacktrace-js";
+import {getLogger} from "./logger";
+import {Dispatch} from "react";
+import {currentRoute} from "./router";
 
-const logger = getLogger("reducer")
+const logger = getLogger("reducer");
 
 type ReducerDef<S extends ReduxState, A extends ReduxAction> = {
-  mapperMany?: ReduceF<S, A>
-  mapperOnce?: ReduceOnceF<S, A>
-  priority?: number
-  key?: string
-  definedIn?: StackTrace.StackFrame
-}
+  mapperMulti?: ReduceF<S, A>;
+  mapperOnce?: ReduceOnceF<S, A>;
+  priority?: number;
+  key?: string;
+  definedIn?: StackTrace.StackFrame;
+  targetMapper?: ReduceF<S, A>;
+};
+
+type Source = {
+  file?: string;
+  line?: number;
+  column?: number;
+  functionName?: string;
+};
 
 export function createReducer(
   initialState: ReduxState,
-  dispatcher: Dispatch<any>,
+  dispatcher: Dispatch<any>
 ): [Reducer<ReduxState, Action>, PiReducer] {
-  const mappings: { [k: string]: ReducerDef<ReduxState, Action>[] } = {}
-  mappings[UPDATE_STATE_ACTION] = [{ mapperMany: RegisterCardState.reducer }]
+  const mappings: {[k: string]: ReducerDef<ReduxState, Action>[]} = {};
+  mappings[UPDATE_STATE_ACTION] = [
+    {
+      mapperMulti: RegisterCardState.reducer,
+      key: "@builtin:card:UPDATE_STATE_ACTION",
+    },
+  ];
 
   const delayedDispatcher = (a: any): void => {
-    setTimeout(() => dispatcher(a), 0)
-  }
+    setTimeout(() => dispatcher(a), 0);
+  };
   const reducer = (
     state: ReduxState | undefined,
-    action: Action,
+    action: Action
   ): ReduxState => {
-    const s = state || initialState
-    const ra = mappings[action.type]
-    const rany = mappings["*"]
+    const s = state || initialState;
+    const ra = mappings[action.type];
+    const rany = mappings["*"];
     if ((!ra || ra.length === 0) && (!rany || rany.length === 0)) {
-      return s
+      return s;
     }
 
     const nextState = produce<ReduxState, ReduxState>(s, (draft) => {
+      if (!draft.pihanga) {
+        draft.pihanga = {};
+      }
+      draft.pihanga.reducers = [];
       if (ra) {
-        const rout = _reduce(ra, draft, action, delayedDispatcher)
-        mappings[action.type] = rout
+        const rout = _reduce(ra, draft, action, delayedDispatcher);
+        mappings[action.type] = rout;
       }
       if (rany) {
-        const rout2 = _reduce(rany, draft, action, delayedDispatcher)
-        mappings["*"] = rout2
+        const rout2 = _reduce(rany, draft, action, delayedDispatcher);
+        mappings["*"] = rout2;
       }
-      return
-    })
-    return nextState
-  }
+      return;
+    });
+    return nextState;
+  };
 
   const registerReducer: PiRegisterReducerF = <
     S extends ReduxState,
-    A extends ReduxAction,
+    A extends ReduxAction
   >(
     eventType: string,
     mapper: ReduceF<S, A>,
     priority: number = 0,
-    key: string | undefined = undefined
+    key?: string,
+    targetMapper?: ReduceF<S, A>
   ): PiReducerCancelF => {
-    return addReducer(eventType, { mapperMany: mapper, priority, key })
-  }
+    return addReducer(eventType, {
+      mapperMulti: mapper,
+      priority,
+      key,
+      targetMapper,
+    });
+  };
 
   const registerOneShot: PiRegisterOneShotReducerF = <
     S extends ReduxState,
-    A extends ReduxAction,
+    A extends ReduxAction
   >(
     eventType: string,
     mapper: (state: S, action: A, dispatch: DispatchF) => boolean,
     priority: number = 0,
     key: string | undefined = undefined
   ): PiReducerCancelF => {
-    return addReducer(eventType, { mapperOnce: mapper, priority, key })
-  }
+    return addReducer(eventType, {mapperOnce: mapper, priority, key});
+  };
 
-  const nonCancelF = () => {}
+  const nonCancelF = () => {};
 
   function addReducer<S extends ReduxState, A extends ReduxAction>(
     eventType: string,
-    reducerDef: ReducerDef<S, A>,
+    reducerDef: ReducerDef<S, A>
   ): PiReducerCancelF {
-    let m = mappings[eventType] || []
-    const key = reducerDef.key
-    m = removeReducer(key, m)
-    m.push(reducerDef as any as ReducerDef<ReduxState, Action<any>>) // keep typing happy
-    m.sort((a, b) => (b.priority || 0) - (a.priority || 0))
-    mappings[eventType] = m
-
-    const callback = (frames: StackTrace.StackFrame[]) => {
-      // const stack = frames.map((sf) => `${sf.fileName}:${sf.lineNumber}`)
-      // console.log(stack)
-      reducerDef.definedIn = frames[2]
-    }
+    let m = mappings[eventType] || [];
+    const key = reducerDef.key;
+    m = removeReducer(key, m);
+    m.push(reducerDef as any as ReducerDef<ReduxState, Action<any>>); // keep typing happy
+    m.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+    mappings[eventType] = m;
 
-    const errback = (err: any) => {
-      logger.warn(err.message)
+    if (!reducerDef.key) {
+      const frames = StackTrace.getSync();
+      const sf = _get_source_frame(frames);
+      if (sf) {
+        // reducerDef.definedIn = sf;
+        reducerDef.key = sf.toString();
+      } else {
+        reducerDef.definedIn = sf;
+        console.log(">> cannot find source frame", eventType, frames);
+      }
     }
-    StackTrace.get().then(callback).catch(errback)
-    return key ? () => {
-      let m = mappings[eventType] || []
-      mappings[eventType] = removeReducer(key, m)
-    } : nonCancelF
+
+    return key
+      ? () => {
+          let m = mappings[eventType] || [];
+          mappings[eventType] = removeReducer(key, m);
+        }
+      : nonCancelF;
   }
 
   const piReducer: PiReducer = {
@@ -120,9 +147,9 @@ export function createReducer(
     registerOneShot,
     dispatch: dispatcher,
     dispatchFromReducer: delayedDispatcher,
-  }
+  };
 
-  return [reducer, piReducer]
+  return [reducer, piReducer];
 }
 
 function removeReducer(
@@ -130,9 +157,9 @@ function removeReducer(
   m: ReducerDef<ReduxState, Action>[]
 ) {
   if (key) {
-    return m.filter((r) => r.key !== key)
+    return m.filter((r) => r.key !== key);
   } else {
-    return m
+    return m;
   }
 }
 
@@ -140,23 +167,53 @@ function _reduce(
   ra: ReducerDef<ReduxState, Action>[],
   draft: ReduxState,
   action: Action,
-  delayedDispatcher: (a: any) => void,
+  delayedDispatcher: (a: any) => void
 ): ReducerDef<ReduxState, Action<any>>[] {
-  const rout: ReducerDef<ReduxState, Action<any>>[] = []
+  const rout: ReducerDef<ReduxState, Action<any>>[] = [];
   ra.forEach((m) => {
     try {
-      if (m.mapperMany) {
-        m.mapperMany(draft, action, delayedDispatcher)
-        rout.push(m)
+      // if (m.definedIn || m.key) {
+      //   console.log(">>> executing reducer", action.type, m.key, m.definedIn);
+      // }
+      if (m.mapperMulti) {
+        draft.pihanga?.reducers?.push(m.definedIn || m.key || "unknown");
+        m.mapperMulti(draft, action, delayedDispatcher);
+        rout.push(m);
       } else if (m.mapperOnce) {
-        const flag = m.mapperOnce(draft, action, delayedDispatcher)
+        draft.pihanga?.reducers?.push(m.definedIn || m.key || "unknown");
+        const flag = m.mapperOnce(draft, action, delayedDispatcher);
         if (!flag) {
-          rout.push(m)
+          rout.push(m);
         }
       }
     } catch (err: any) {
-      logger.error(err.message, m.definedIn)
+      logger.error(err.message, m.definedIn);
+    }
+  });
+  return rout;
+}
+
+function _get_source_frame(
+  frames: StackTrace.StackFrame[]
+): StackTrace.StackFrame | undefined {
+  // Heuristic: frame 0 = Error, 1 = getCallerSiteInBrowser, 2 = your function, 3 = its caller
+  for (let i = 3; i < frames.length; i++) {
+    const f = frames[i];
+    const fn = f.fileName;
+    if (_is_src_file(fn)) {
+      return f;
     }
-  })
-  return rout
-}
+  }
+  return undefined;
+}
+
+function _is_src_file(url: string | undefined): boolean {
+  if (!url) return false;
+  const m = url.match(/^(?:[a-z][a-z0-9+.-]*:)?\/\/[^\/]+\/([^\/?#]+)/);
+  if (m) {
+    const p1 = m[1];
+    const flag = !(p1.startsWith("@") || p1 === "node_modules");
+    return flag;
+  }
+  return true;
+}

package/src/redux.ts

@@ -1,8 +1,8 @@
-import { PiRegister } from "."
-import { pihanga as logger } from "./logger"
-import { CardAction, ReduceF, ReduxState } from "./types"
+import {PiRegister} from ".";
+import {pihanga as logger} from "./logger";
+import {CardAction, ReduceF, ReduxState} from "./types";
 
-const ns2Actions: { [k: string]: boolean } = {}
+const ns2Actions: {[k: string]: boolean} = {};
 
 /**
  * Register a set of actions for a particular namespace.
@@ -18,32 +18,32 @@ const ns2Actions: { [k: string]: boolean } = {}
  */
 export function registerActions<T extends string>(
   namespace: string,
-  actions: readonly T[],
-): { [S in Uppercase<T>]: string } {
+  actions: readonly T[]
+): {[S in Uppercase<T>]: string} {
   if (ns2Actions[namespace]) {
-    logger.warn(`Overwriting action namespace  "${namespace}"`)
+    logger.warn(`Overwriting action namespace  "${namespace}"`);
   }
-  const ah: any = {}
+  const ah: any = {};
   actions.forEach((a) => {
-    ah[a.toUpperCase()] = `${namespace}/${a}`
-  })
-  logger.info(`Register action ns "${namespace}"`)
-  ns2Actions[namespace] = true
-  return ah as { [S in Uppercase<T>]: string }
+    ah[a.toUpperCase()] = `${namespace}/${a}`;
+  });
+  logger.info(`Register action ns "${namespace}"`);
+  ns2Actions[namespace] = true;
+  return ah as {[S in Uppercase<T>]: string};
 }
 
-export function actionTypesToEvents(actionTypes: { [k: string]: string }): {
-  [k: string]: string
+export function actionTypesToEvents(actionTypes: {[k: string]: string}): {
+  [k: string]: string;
 } {
   return Object.entries(actionTypes).reduce((p, el) => {
-    const [k, v] = el
+    const [k, v] = el;
     const n = k
       .split("_")
       .map((s) => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase())
-      .join("")
-    p[`on${n}`] = v
-    return p
-  }, {} as { [k: string]: string })
+      .join("");
+    p[`on${n}`] = v;
+    return p;
+  }, {} as {[k: string]: string});
 }
 
 /**
@@ -53,12 +53,13 @@ export function actionTypesToEvents(actionTypes: { [k: string]: string }): {
  * @param {string} actionType
  * @returns a function to register a reducer for 'actionType'
  */
-export function createOnAction<E>(actionType: string): <S extends ReduxState>(
+export function createOnAction<E>(
+  actionType: string
+): <S extends ReduxState>(
   register: PiRegister,
-  //f: (state: S, ev: CardAction & E) => S,
-  f: ReduceF<S, CardAction & E>,
+  f: ReduceF<S, CardAction & E>
 ) => void {
   return (register, f) => {
-    register.reducer.register(actionType, f)
-  }
+    register.reducer.register(actionType, f);
+  };
 }

package/src/register.ts

@@ -0,0 +1,31 @@
+// type RegisterCbk = (register: PiRegister) => void;
+
+// // These remain private and shared across all imports
+// let registerF: PiRegister | null = null;
+// let pendingRegistrations: RegisterCbk[] = [];
+// const MAX_BUFFER_SIZE = 100; // Prevent memory leaks
+
+// export function registerCallback<T>(cb: RegisterCbk): void {
+//   registerF = cb;
+
+//   // Flush buffer
+//   while (pendingRegistrations.length > 0) {
+//     const cbk = pendingRegistrations.shift();
+//     if (cbk) {
+//       cbk(registerF);
+//     }
+//   }
+// }
+
+// export function register(cbk: RegisterCbk): void {
+//   if (registerF) {
+//     cbk(registerF);
+//   } else {
+//     pendingRegistrations.push(cbk);
+//   }
+// }
+
+// // Added: Helper to clear the buffer if needed
+// export function clearPendingRegistration(): void {
+//   pendingRegistrations = [];
+// }

package/src/register_cards.ts

@@ -1,5 +1,5 @@
 import equal from "deep-equal";
-import { getLogger } from "./logger";
+import {getLogger} from "./logger";
 import {
   CSSModuleClasses,
   CardAction,
@@ -18,7 +18,7 @@ import {
   StateMapper,
   StateMapperContext,
 } from "./types";
-import { Action, AnyAction, Dispatch } from "@reduxjs/toolkit";
+import {Action, AnyAction, Dispatch} from "@reduxjs/toolkit";
 
 const logger = getLogger("card-register");
 
@@ -28,11 +28,11 @@ export function isCardRef(p: any): boolean {
 
 export type Mapping = {
   cardType: string;
-  props: { [k: string]: unknown };
+  props: {[k: string]: unknown};
   eventMappers: {
     [k: string]: (ev: Action, ctxtProps: CardProp) => Action | null;
   };
-  cardEvents: { [key: string]: string };
+  cardEvents: {[key: string]: string};
   parameters: PiCardDef; // original
 };
 
@@ -40,20 +40,20 @@ export type MetaCard = {
   type: string;
   registerCard: RegisterCardF;
   mapper: MetaCardMapperF;
-  events?: { [key: string]: string };
+  events?: {[key: string]: string};
 };
 
-export const cardTypes: { [k: string]: PiRegisterComponent } = {};
-export const metacardTypes: { [k: string]: MetaCard } = {};
+export const cardTypes: {[k: string]: PiRegisterComponent} = {};
+export const metacardTypes: {[k: string]: MetaCard} = {};
 
 export let framework: string; // name of active UI framework
-export const cardMappings: { [k: string]: Mapping } = {};
+export const cardMappings: {[k: string]: Mapping} = {};
 export const dispatch2registerReducer: [
   React.Dispatch<any>,
   PiRegisterReducerF
 ][] = [];
 
-export function registerCardComponent(card: PiRegisterComponent): void {
+export function addCardComponent(card: PiRegisterComponent): void {
   if (cardTypes[card.name]) {
     logger.warn(`Overwriting definition for card type "${card.name}"`);
   }
@@ -71,17 +71,17 @@ export function registerCardComponent(card: PiRegisterComponent): void {
 
 export function registerMetacard(registerCard: RegisterCardF) {
   function f<C>(declaration: PiRegisterMetaCard) {
-    const { type, mapper, events } = declaration;
+    const {type, mapper, events} = declaration;
     if (metacardTypes[type]) {
       logger.warn(`Overwriting definition for meta card type "${type}"`);
     }
     logger.info(`Register meta card type "${type}"`);
-    metacardTypes[type] = { type, registerCard, mapper, events };
+    metacardTypes[type] = {type, registerCard, mapper, events};
   }
   return f;
 }
 
-export function registerCard(
+export function addCard(
   registerReducer: PiRegisterReducerF,
   dispatchF: React.Dispatch<any>
 ) {
@@ -100,7 +100,7 @@ export function updateOrRegisterCard(
   dispatch2registerReducer.push([dispatchF, registerReducer]);
   return (
     name: string,
-    parameters: { [key: string]: GenericCardParameterT }
+    parameters: {[key: string]: GenericCardParameterT}
   ): PiCardRef => {
     return _updateCard(name, parameters, registerReducer);
   };
@@ -110,7 +110,7 @@ export function _registerCard(
   name: string,
   parameters: PiCardDef,
   registerReducer: PiRegisterReducerF,
-  overrideEvents?: { [key: string]: string }
+  overrideEvents?: {[key: string]: string}
 ): PiCardRef {
   if (cardMappings[name]) {
     logger.warn(`Overwriting definition for card "${name}"`);
@@ -137,9 +137,9 @@ export function _registerCard(
 
 export function _updateCard(
   name: string,
-  parameters: { [key: string]: GenericCardParameterT },
+  parameters: {[key: string]: GenericCardParameterT},
   registerReducer: PiRegisterReducerF,
-  overrideEvents?: { [key: string]: string }
+  overrideEvents?: {[key: string]: string}
 ): PiCardRef {
   const mappings = cardMappings[name];
   if (!mappings) {
@@ -152,7 +152,7 @@ export function _updateCard(
     return _registerCard(name, p, registerReducer, overrideEvents);
   }
 
-  const p = { ...mappings.parameters, ...parameters };
+  const p = {...mappings.parameters, ...parameters};
   _createCardMapping(name, p, registerReducer, mappings.cardEvents);
   return name;
 }
@@ -161,10 +161,10 @@ export function _createCardMapping(
   name: string,
   parameters: PiCardDef,
   registerReducer: PiRegisterReducerF,
-  cardEvents: { [key: string]: string }
+  cardEvents: {[key: string]: string}
 ) {
-  const props = {} as { [k: string]: unknown };
-  const eventMappers = {} as { [k: string]: (ev: Action) => Action };
+  const props = {} as {[k: string]: unknown};
+  const eventMappers = {} as {[k: string]: (ev: Action) => Action};
 
   Object.entries(parameters).forEach(([k, v]) => {
     if (k === "cardType") return;
@@ -272,8 +272,8 @@ export function createCardDeclaration<Props = {}, Events = {}>(
 function processEventParameter(
   propName: string,
   value: unknown,
-  events: { [key: string]: string },
-  eventMappers: { [k: string]: (ev: Action) => Action },
+  events: {[key: string]: string},
+  eventMappers: {[k: string]: (ev: Action) => Action},
   registerReducer: PiRegisterReducerF,
   cardName: string
 ): boolean {
@@ -304,7 +304,8 @@ function processEventParameter(
         return s;
       },
       0,
-      `${cardName}|${propName}`
+      `on card ${cardName} for ${propName}`,
+      r
     );
   }
   if (propName === `${evName}Mapper`) {
@@ -350,9 +351,9 @@ export function memo<P, T, S extends ReduxState, C = any>(
   filterF: (state: S, context: StateMapperContext<C>) => P,
   mapperF: (partial: P, context: StateMapperContext<C>, state: S) => T
 ): (state: S, context: StateMapperContext<C>) => T {
-  const lastFilter: { [k: string]: P } = {};
-  const lastValue: { [k: string]: T } = {};
-  const isNotFirst: { [k: string]: boolean } = {};
+  const lastFilter: {[k: string]: P} = {};
+  const lastValue: {[k: string]: T} = {};
+  const isNotFirst: {[k: string]: boolean} = {};
 
   return (state: S, context: StateMapperContext<C>): T => {
     const k = context.cardKey || "-";