@player-tools/devtools-client 0.2.2--canary.19.409 → 0.2.2--canary.17.433

package/dist/index.esm.js

@@ -1,30 +1,10 @@
-import { createLogger, BACKGROUND_SOURCE, Runtime, playerTimelineAction, playerViewUpdateAction, playerFlowStartAction, playerRemoveAction, selectedPlayerAction, playerInitAction, clearStore, createRPCRequest, PANEL_SOURCE } from '@player-tools/devtools-common';
-export * from '@player-tools/devtools-common';
-import { createAsyncThunk } from '@reduxjs/toolkit';
+import { createAction, createAsyncThunk, createListenerMiddleware, isAnyOf, createReducer, createSelector, configureStore } from '@reduxjs/toolkit';
+import { Events, createLogger, BACKGROUND_SOURCE, Methods, RUNTIME_SOURCE } from '@player-tools/devtools-common';
 
-const GET_INFO_DETAILS = "GET_INFO_DETAILS";
-const GET_CONFIG_DETAILS = "GET_CONFIG_DETAILS";
-const GET_VIEW_DETAILS = "GET_VIEW_DETAILS";
-const GET_DATA_BINDING_DETAILS = "GET_DATA_BINDING_DETAILS";
-const GET_CONSOLE_EVAL = "GET_CONSOLE_EVAL";
-const START_PROFILER = "START_PROFILER";
-const STOP_PROFILER = "STOP_PROFILER";
-const _alias = (aliases) => () => (next) => (action) => {
-  const alias = aliases[action.type];
-  if (alias) {
-    return next(alias(action));
-  }
-  return next(action);
-};
-const buildAliases = (actions) => _alias({
-  GET_INFO_DETAILS: (action) => actions["player-runtime-info-request"](action.payload),
-  GET_CONFIG_DETAILS: (action) => actions["player-config-request"](action.payload),
-  GET_VIEW_DETAILS: (action) => actions["player-view-details-request"](action.payload),
-  GET_DATA_BINDING_DETAILS: (action) => actions["player-data-binding-details"](action.payload),
-  GET_CONSOLE_EVAL: (action) => actions["player-execute-expression"](action.payload),
-  START_PROFILER: (action) => actions["player-start-profiler-request"](action.payload),
-  STOP_PROFILER: (action) => actions["player-stop-profiler-request"](action.payload)
-});
+const Actions$1 = Object.fromEntries(Events.EventTypes.map((event) => [
+  event,
+  createAction(event)
+]));
 
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
@@ -47,18 +27,121 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 const logger = createLogger(BACKGROUND_SOURCE);
-const buildRPCActions = (handlers) => Runtime.RuntimeRPCTypes.reduce((acc, rpcType) => {
-  acc[rpcType] = createAsyncThunk(rpcType, (params) => __async(undefined, null, function* () {
-    logger.log(`Requesting ${rpcType}`, params);
-    const data = yield handlers[rpcType].call(params);
-    logger.log(`Response from ${rpcType}`, data);
+const buildMethodThunks = (onMethodRequest) => Object.fromEntries(Methods.MethodTypes.map((method) => [
+  method,
+  createAsyncThunk(method, (method2) => __async(undefined, null, function* () {
+    logger.log(`Requesting ${method2.type}`, method2.params);
+    const data = yield onMethodRequest(method2);
+    logger.log(`Response from ${method2.type}`, data);
     return data;
-  }));
-  return acc;
-}, {});
+  }))
+]));
+
+const Actions = {
+  "selected-player": createAction("selected-player"),
+  "player-timeline-event": createAction("player-timeline-event"),
+  "clear-selected-data-details": createAction("clear-selected-data-details"),
+  "clear-console": createAction("clear-console"),
+  "clear-logs": createAction("clear-logs"),
+  "clear-store": createAction("clear-store")
+};
+
+const GET_INFO_DETAILS = "GET_INFO_DETAILS";
+const GET_CONFIG_DETAILS = "GET_CONFIG_DETAILS";
+const GET_VIEW_DETAILS = "GET_VIEW_DETAILS";
+const GET_DATA_BINDING_DETAILS = "GET_DATA_BINDING_DETAILS";
+const GET_CONSOLE_EVAL = "GET_CONSOLE_EVAL";
+const START_PROFILER = "START_PROFILER";
+const STOP_PROFILER = "STOP_PROFILER";
+const _alias = (aliases) => () => (next) => (action) => {
+  const alias2 = aliases[action.type];
+  if (alias2) {
+    return next(alias2(action));
+  }
+  return next(action);
+};
+const alias = (type, methods) => (action) => methods[type]({
+  type,
+  params: action.payload,
+  source: RUNTIME_SOURCE
+});
+const buildAliases = (methods) => _alias({
+  GET_INFO_DETAILS: alias("player-runtime-info-request", methods),
+  GET_CONFIG_DETAILS: alias("player-config-request", methods),
+  GET_VIEW_DETAILS: alias("player-view-details-request", methods),
+  GET_DATA_BINDING_DETAILS: alias("player-data-binding-details", methods),
+  GET_CONSOLE_EVAL: alias("player-execute-expression", methods),
+  START_PROFILER: alias("player-start-profiler-request", methods),
+  STOP_PROFILER: alias("player-stop-profiler-request", methods)
+});
+
+const dispatchEvents = (dispatch) => (message) => {
+  if (Events.isEvent(message))
+    dispatch(Actions$1[message.type](message));
+};
 
-const buildPlayerReducerCallback = (actions) => (builder) => {
-  builder.addCase(actions["player-runtime-info-request"].fulfilled, (state, action) => {
+const listenerMiddleware = createListenerMiddleware();
+listenerMiddleware.startListening({
+  matcher: isAnyOf(Actions$1["player-data-change-event"], Actions$1["player-log-event"], Actions$1["player-flow-start"]),
+  effect: (action, api) => {
+    api.dispatch(Actions["player-timeline-event"](action.payload));
+  }
+});
+listenerMiddleware.startListening({
+  actionCreator: Actions$1["runtime-init"],
+  effect: (_, api) => {
+    api.dispatch(Actions["clear-store"]());
+  }
+});
+listenerMiddleware.startListening({
+  matcher: isAnyOf(Actions$1["player-init"], Actions$1["player-removed"]),
+  effect: (_, api) => {
+    api.dispatch(Actions["selected-player"]());
+  }
+});
+listenerMiddleware.startListening({
+  matcher: isAnyOf(Actions$1["player-flow-start"], Actions$1["player-data-change-event"]),
+  effect: (action, api) => {
+    const { players } = api.getState();
+    const { playerID } = action.payload;
+    if (players.activePlayers[playerID] && players.activePlayers[playerID].dataState.selectedBinding) {
+      api.dispatch({
+        type: GET_DATA_BINDING_DETAILS,
+        payload: { playerID, binding: players.activePlayers[playerID].dataState.selectedBinding }
+      });
+    }
+    api.dispatch({
+      type: GET_DATA_BINDING_DETAILS,
+      payload: { playerID, binding: "" }
+    });
+  }
+});
+
+var __defProp$1 = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const initialState = {
+  selectedPlayerId: null,
+  activePlayers: {}
+};
+const methodsReducer = (methods) => (builder) => {
+  builder.addCase(methods["player-runtime-info-request"].fulfilled, (state, action) => {
     const { activePlayers, selectedPlayerId } = state;
     if (!selectedPlayerId) {
       return;
@@ -66,14 +149,14 @@ const buildPlayerReducerCallback = (actions) => (builder) => {
     const data = action.payload && Object.keys(action.payload).length > 0 ? action.payload : null;
     activePlayers[selectedPlayerId].flowInfo = data;
   });
-  builder.addCase(actions["player-config-request"].fulfilled, (state, action) => {
+  builder.addCase(methods["player-config-request"].fulfilled, (state, action) => {
     const { activePlayers, selectedPlayerId } = state;
     if (!selectedPlayerId) {
       return;
     }
     activePlayers[selectedPlayerId].configState = action.payload;
   });
-  builder.addCase(actions["player-view-details-request"].fulfilled, (state, action) => {
+  builder.addCase(methods["player-view-details-request"].fulfilled, (state, action) => {
     var _a;
     const { activePlayers, selectedPlayerId } = state;
     if (!selectedPlayerId) {
@@ -81,10 +164,10 @@ const buildPlayerReducerCallback = (actions) => (builder) => {
     }
     activePlayers[selectedPlayerId].view = (_a = action.payload) == null ? void 0 : _a.lastViewUpdate;
   });
-  builder.addCase(actions["player-data-binding-details"].fulfilled, (state, action) => {
+  builder.addCase(methods["player-data-binding-details"].fulfilled, (state, action) => {
     const {
       meta: {
-        arg: { binding, playerID }
+        arg: { params: { binding, playerID } }
       },
       payload
     } = action;
@@ -98,7 +181,7 @@ const buildPlayerReducerCallback = (actions) => (builder) => {
     }
     activePlayers[playerID].dataState.selectedBinding = payload;
   });
-  builder.addCase(actions["player-execute-expression"].fulfilled, (state, action) => {
+  builder.addCase(methods["player-execute-expression"].fulfilled, (state, action) => {
     var _a, _b, _c, _d;
     const { activePlayers, selectedPlayerId } = state;
     if (!selectedPlayerId) {
@@ -110,14 +193,14 @@ const buildPlayerReducerCallback = (actions) => (builder) => {
       expression: (_c = (_b = action.payload) == null ? void 0 : _b.exp) != null ? _c : ""
     });
   });
-  builder.addCase(actions["player-start-profiler-request"].fulfilled, (state, action) => {
+  builder.addCase(methods["player-start-profiler-request"].fulfilled, (state, action) => {
     var _a;
     const { activePlayers, selectedPlayerId } = state;
     if (!selectedPlayerId)
       return;
     activePlayers[selectedPlayerId].profilerInfo = (_a = action.payload) == null ? void 0 : _a.data;
   });
-  builder.addCase(actions["player-stop-profiler-request"].fulfilled, (state, action) => {
+  builder.addCase(methods["player-stop-profiler-request"].fulfilled, (state, action) => {
     var _a;
     const { activePlayers, selectedPlayerId } = state;
     if (!selectedPlayerId)
@@ -125,59 +208,200 @@ const buildPlayerReducerCallback = (actions) => (builder) => {
     activePlayers[selectedPlayerId].profilerInfo = (_a = action.payload) == null ? void 0 : _a.data;
   });
 };
-
-function handleMessage(store, message) {
-  switch (message.type) {
-    case "runtime-init":
-      store.dispatch(clearStore());
-      break;
-    case "player-init":
-      store.dispatch(playerInitAction(message));
-      store.dispatch(selectedPlayerAction());
-      break;
-    case "player-removed":
-      store.dispatch(playerRemoveAction(message.playerID));
-      store.dispatch(selectedPlayerAction());
-      break;
-    case "player-flow-start":
-      store.dispatch(playerFlowStartAction(message));
-      store.dispatch(playerTimelineAction(message));
-      store.dispatch({
-        type: GET_DATA_BINDING_DETAILS,
-        payload: { playerID: message.playerID, binding: "" }
-      });
-      break;
-    case "player-log-event":
-      store.dispatch(playerTimelineAction(message));
-      break;
-    case "player-view-update-event":
-      store.dispatch(playerViewUpdateAction(message));
-      break;
-    case "player-data-change-event": {
-      const { players } = store.getState();
-      if (players.activePlayers[message.playerID] && players.activePlayers[message.playerID].dataState.selectedBinding) {
-        store.dispatch({
-          type: GET_DATA_BINDING_DETAILS,
-          payload: message
-        });
-      }
-      store.dispatch({
-        type: GET_DATA_BINDING_DETAILS,
-        payload: { playerID: message.playerID, binding: "" }
-      });
-      store.dispatch(playerTimelineAction(message));
-      break;
+const eventsReducer = (builder) => {
+  builder.addCase(Actions$1["player-init"], (state, action) => {
+    const {
+      payload: { version, playerID }
+    } = action;
+    state.activePlayers[playerID] = {
+      timelineEvents: [],
+      dataState: {},
+      consoleState: { history: [] }
+    };
+    state.version = version;
+  });
+  builder.addCase(Actions$1["player-removed"], (state, action) => {
+    delete state.activePlayers[action.payload.playerID];
+  });
+  builder.addCase(Actions$1["player-flow-start"], (state, action) => {
+    const {
+      payload: { flow, playerID }
+    } = action;
+    if (!state.activePlayers[playerID]) {
+      state.activePlayers[playerID] = {
+        flowInfo: { currentFlow: flow },
+        timelineEvents: [],
+        dataState: {},
+        consoleState: { history: [] }
+      };
+      state.selectedPlayerId = playerID;
+      return;
+    }
+    state.activePlayers[playerID].flowInfo = __spreadProps(__spreadValues$1({}, state.activePlayers[playerID].flowInfo), {
+      currentFlow: flow
+    });
+  });
+  builder.addCase(Actions$1["player-view-update-event"], (state, action) => {
+    const {
+      payload: { playerID, update }
+    } = action;
+    if (!state.activePlayers[playerID]) {
+      state.activePlayers[playerID] = {
+        view: update,
+        timelineEvents: [],
+        dataState: {},
+        consoleState: { history: [] }
+      };
+      state.selectedPlayerId = playerID;
+      return;
+    }
+    state.activePlayers[playerID].view = update;
+  });
+};
+const actionsReducer = (builder) => {
+  builder.addCase(Actions["selected-player"], (state, action) => {
+    if (action.payload) {
+      state.selectedPlayerId = action.payload;
+      return;
+    }
+    state.selectedPlayerId = Object.keys(state.activePlayers)[0] || null;
+  });
+  builder.addCase(Actions["player-timeline-event"], (state, action) => {
+    const {
+      payload: { playerID }
+    } = action;
+    if (!state.activePlayers[playerID]) {
+      state.activePlayers[playerID] = {
+        timelineEvents: [action.payload],
+        dataState: {},
+        consoleState: { history: [] }
+      };
+      state.selectedPlayerId = playerID;
+      return;
+    }
+    state.activePlayers[playerID].timelineEvents.push(action.payload);
+  });
+  builder.addCase(Actions["clear-selected-data-details"], (state) => {
+    const { activePlayers, selectedPlayerId } = state;
+    if (!selectedPlayerId || !activePlayers[selectedPlayerId]) {
+      return;
+    }
+    activePlayers[selectedPlayerId].dataState.selectedBinding = void 0;
+  });
+  builder.addCase(Actions["clear-console"], (state) => {
+    const { activePlayers, selectedPlayerId } = state;
+    if (!selectedPlayerId) {
+      return;
+    }
+    activePlayers[selectedPlayerId].consoleState = {
+      history: []
+    };
+  });
+  builder.addCase(Actions["clear-logs"], (state) => {
+    const { activePlayers, selectedPlayerId } = state;
+    if (!selectedPlayerId) {
+      return;
     }
-    default:
-      console.warn(`Unhandled event: ${JSON.stringify(message)}`);
-      break;
+    activePlayers[selectedPlayerId].timelineEvents = [];
+  });
+  builder.addCase(Actions["clear-store"], () => {
+    return initialState;
+  });
+};
+const playersReducer = (methods) => createReducer(initialState, (builder) => {
+  actionsReducer(builder);
+  eventsReducer(builder);
+  methodsReducer(methods)(builder);
+});
+
+const selectPlayers = (state) => {
+  return state.players;
+};
+const selectActivePlayers = createSelector(selectPlayers, (players) => players.activePlayers);
+const selectPlayerVersion = createSelector(selectPlayers, (players) => players.version);
+const selectPlayerIds = createSelector(selectActivePlayers, (activePlayers) => Object.keys(activePlayers) || []);
+const selectSelectedPlayerId = createSelector(selectPlayers, (players) => players.selectedPlayerId);
+const selectCurrentPlayer = createSelector(selectActivePlayers, selectSelectedPlayerId, (activePlayers, selectedPlayerId) => {
+  if (!selectedPlayerId) {
+    return null;
   }
-}
+  return activePlayers[selectedPlayerId];
+});
+const selectConfig = createSelector(selectCurrentPlayer, (currentPlayer) => {
+  var _a;
+  return (_a = currentPlayer == null ? void 0 : currentPlayer.configState) != null ? _a : null;
+});
+const selectData = createSelector(selectCurrentPlayer, (currentPlayer) => {
+  return currentPlayer == null ? void 0 : currentPlayer.dataState;
+});
+const selectFlowInfo = createSelector(selectCurrentPlayer, (currentPlayer) => {
+  if (!currentPlayer) {
+    return null;
+  }
+  return currentPlayer == null ? void 0 : currentPlayer.flowInfo;
+});
+const selectCurrentFlow = createSelector(selectFlowInfo, (flowInfo) => {
+  return flowInfo == null ? void 0 : flowInfo.currentFlow;
+});
+const selectCurrentTopic = createSelector(selectCurrentFlow, (currentFlow) => {
+  return currentFlow == null ? void 0 : currentFlow.topic;
+});
+const selectEvents = createSelector(selectCurrentPlayer, (currentPlayer) => {
+  if (!currentPlayer) {
+    return [];
+  }
+  return currentPlayer == null ? void 0 : currentPlayer.timelineEvents;
+});
+const selectView = createSelector(selectCurrentPlayer, (currentPlayer) => {
+  if (!currentPlayer) {
+    return null;
+  }
+  return currentPlayer == null ? void 0 : currentPlayer.view;
+});
+const selectAllBindings = createSelector(selectData, (data) => {
+  return data == null ? void 0 : data.allBindings;
+});
+const selectSelectedBinding = createSelector(selectData, (data) => {
+  return data == null ? void 0 : data.selectedBinding;
+});
+const selectConsole = createSelector(selectCurrentPlayer, (currentPlayer) => {
+  if (!currentPlayer) {
+    return { history: [] };
+  }
+  return currentPlayer.consoleState;
+});
+const selectProfiler = createSelector(selectCurrentPlayer, (currentPlayer) => {
+  return currentPlayer == null ? void 0 : currentPlayer.profilerInfo;
+});
 
-const buildRPCRequests = (onRequestMessage) => Runtime.RuntimeRPCTypes.reduce((acc, rpcType) => {
-  acc[rpcType] = createRPCRequest(rpcType, PANEL_SOURCE, onRequestMessage);
-  return acc;
-}, {});
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+const createStore = (methodThunks, middleware, reducers) => configureStore({
+  reducer: __spreadValues({
+    players: playersReducer(methodThunks)
+  }, reducers),
+  middleware: (getDefaultMiddleware) => {
+    const m = getDefaultMiddleware().prepend(buildAliases(methodThunks)).concat(listenerMiddleware.middleware);
+    if (middleware)
+      m.concat(middleware);
+    return m;
+  }
+});
+const createDevtoolsStore = (onMethodRequest, middleware, additionalReducers) => createStore(buildMethodThunks(onMethodRequest), middleware, additionalReducers);
 
-export { GET_CONFIG_DETAILS, GET_CONSOLE_EVAL, GET_DATA_BINDING_DETAILS, GET_INFO_DETAILS, GET_VIEW_DETAILS, START_PROFILER, STOP_PROFILER, buildAliases, buildPlayerReducerCallback, buildRPCActions, buildRPCRequests, handleMessage };
+export { Actions, Actions$1 as EventActions, GET_CONFIG_DETAILS, GET_CONSOLE_EVAL, GET_DATA_BINDING_DETAILS, GET_INFO_DETAILS, GET_VIEW_DETAILS, START_PROFILER, STOP_PROFILER, buildAliases, buildMethodThunks, createDevtoolsStore, dispatchEvents, listenerMiddleware, playersReducer, selectAllBindings, selectConfig, selectConsole, selectCurrentFlow, selectCurrentPlayer, selectCurrentTopic, selectEvents, selectFlowInfo, selectPlayerIds, selectPlayerVersion, selectProfiler, selectSelectedBinding, selectSelectedPlayerId, selectView };
 //# sourceMappingURL=index.esm.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@player-tools/devtools-client",
-  "version": "0.2.2--canary.19.409",
+  "version": "0.2.2--canary.17.433",
   "private": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
@@ -8,7 +8,7 @@
   "peerDependencies": {},
   "dependencies": {
     "@reduxjs/toolkit": "^1.6.1",
-    "@player-tools/devtools-common": "0.2.2--canary.19.409",
+    "@player-tools/devtools-common": "0.2.2--canary.17.433",
     "@babel/runtime": "7.15.4"
   },
   "main": "dist/index.cjs.js",

package/src/index.ts

@@ -1,3 +1 @@
 export * from './redux';
-export * from './rpc';
-export * from '@player-tools/devtools-common';

package/src/redux/actions/events.ts

@@ -0,0 +1,16 @@
+import { Events } from '@player-tools/devtools-common';
+import { ActionCreatorWithPayload, createAction } from '@reduxjs/toolkit';
+import { AnyAction } from 'redux';
+
+/** Redux actions associated against all possible event types */
+type EventActions = {
+  [key in Events.EventTypes]: ActionCreatorWithPayload<Events.ByType<key>, key>;
+};
+
+/** Redux actions associated against all defined event types */
+export const Actions: EventActions = Object.fromEntries(
+  Events.EventTypes.map((event) => [
+    event,
+    createAction<Events.ByType<typeof event>>(event),
+  ])
+) as EventActions;

package/src/redux/actions/index.ts

@@ -0,0 +1,20 @@
+import { createAction } from '@reduxjs/toolkit';
+import type { Events } from '@player-tools/devtools-common';
+
+export { Actions as EventActions } from './events';
+export * from './methods';
+
+/** Explicit actions that don't correspond to a specific event or method */
+export const Actions = {
+  // Explicit actions TODO: Is this level of redundancy okay?
+  'selected-player': createAction<string | undefined>('selected-player'),
+  'player-timeline-event': createAction<Events.TimelineEvents>(
+    'player-timeline-event'
+  ),
+
+  // Reset actions
+  'clear-selected-data-details': createAction('clear-selected-data-details'),
+  'clear-console': createAction('clear-console'),
+  'clear-logs': createAction('clear-logs'),
+  'clear-store': createAction('clear-store'),
+};

package/src/redux/actions/methods.ts

@@ -0,0 +1,43 @@
+import {
+  BACKGROUND_SOURCE,
+  createLogger,
+  Methods,
+} from '@player-tools/devtools-common';
+import { createAsyncThunk, type AsyncThunk } from '@reduxjs/toolkit';
+
+const logger = createLogger(BACKGROUND_SOURCE);
+
+/** Type describing an object containing async thunks for each Method defined */
+export type MethodThunks = {
+  [key in Methods.Method['type']]: AsyncThunk<
+    Methods.ByType<key>['result'],
+    Methods.ByType<key>,
+    any
+  >;
+};
+
+/** Signature for handling method requests */
+export type MethodHandler = <T extends Methods.MethodTypes>(
+  method: Methods.ByType<T>
+) => Promise<Methods.ByType<T>['result']>;
+
+/** Utility for building async thunks for all known method types */
+export const buildMethodThunks = (
+  onMethodRequest: MethodHandler
+): MethodThunks =>
+  Object.fromEntries(
+    Methods.MethodTypes.map((method) => [
+      method,
+      createAsyncThunk<
+        Methods.ByType<typeof method>['result'],
+        Methods.ByType<typeof method>
+      >(method, async (method) => {
+        logger.log(`Requesting ${method.type}`, method.params);
+        const data = (await onMethodRequest(method)) as Methods.ByType<
+          typeof method.type
+        >['result'];
+        logger.log(`Response from ${method.type}`, data);
+        return data;
+      }),
+    ])
+  ) as MethodThunks;

package/src/redux/aliases.ts

@@ -1,12 +1,5 @@
-import type {
-  AliasAction,
-  ConfigAction,
-  DataBindingAction,
-  ExpressionAction,
-  StartProfilerAction,
-  StopProfilerAction,
-} from '@player-tools/devtools-common';
-import type { AsyncRPCActions } from './actions';
+import { Methods as Methods, RUNTIME_SOURCE } from '@player-tools/devtools-common';
+import { MethodThunks } from './actions/methods';
 
 export const GET_INFO_DETAILS = 'GET_INFO_DETAILS';
 export const GET_CONFIG_DETAILS = 'GET_CONFIG_DETAILS';
@@ -16,6 +9,12 @@ export const GET_CONSOLE_EVAL = 'GET_CONSOLE_EVAL';
 export const START_PROFILER = 'START_PROFILER';
 export const STOP_PROFILER = 'STOP_PROFILER';
 
+
+interface MethodAction<T extends Methods.MethodTypes> {
+  payload: Methods.ByType<T>['params'];
+}
+
+// Copied from webext redux library not allowed in flipper
 const _alias = (aliases: any) => () => (next: any) => (action: any) => {
   const alias = aliases[action.type];
 
@@ -26,20 +25,20 @@ const _alias = (aliases: any) => () => (next: any) => (action: any) => {
   return next(action);
 };
 
-export const buildAliases = (actions: AsyncRPCActions) =>
+/** Helper for building corresponding method action via supplied thunks */
+const alias = <T extends Methods.MethodTypes>(type: T, methods: MethodThunks) => (action: MethodAction<T>) => methods[type]({
+  type,
+  params: action.payload,
+  source: RUNTIME_SOURCE,
+} as Methods.ByType<T>)
+
+export const buildAliases = (methods: MethodThunks) =>
   _alias({
-    GET_INFO_DETAILS: (action: AliasAction) =>
-      actions['player-runtime-info-request'](action.payload),
-    GET_CONFIG_DETAILS: (action: ConfigAction) =>
-      actions['player-config-request'](action.payload),
-    GET_VIEW_DETAILS: (action: AliasAction) =>
-      actions['player-view-details-request'](action.payload),
-    GET_DATA_BINDING_DETAILS: (action: DataBindingAction) =>
-      actions['player-data-binding-details'](action.payload),
-    GET_CONSOLE_EVAL: (action: ExpressionAction) =>
-      actions['player-execute-expression'](action.payload),
-    START_PROFILER: (action: StartProfilerAction) =>
-      actions['player-start-profiler-request'](action.payload),
-    STOP_PROFILER: (action: StopProfilerAction) =>
-      actions['player-stop-profiler-request'](action.payload),
+    GET_INFO_DETAILS: alias('player-runtime-info-request', methods),
+    GET_CONFIG_DETAILS: alias('player-config-request', methods),
+    GET_VIEW_DETAILS: alias('player-view-details-request', methods),
+    GET_DATA_BINDING_DETAILS: alias('player-data-binding-details', methods),
+    GET_CONSOLE_EVAL: alias('player-execute-expression', methods),
+    START_PROFILER: alias('player-start-profiler-request', methods),
+    STOP_PROFILER: alias('player-stop-profiler-request', methods),
   });