@player-tools/devtools-client 0.2.1 → 0.2.2--canary.17.363

package/dist/index.esm.js

@@ -1,30 +1,5 @@
-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';
-
-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)
-});
+import { createAsyncThunk, createAction, createReducer, createSelector, createListenerMiddleware, isAnyOf, configureStore } from '@reduxjs/toolkit';
+import { createLogger, BACKGROUND_SOURCE, Methods as Methods$1, Events as Events$1 } from '@player-tools/devtools-common';
 
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
@@ -47,18 +22,85 @@ 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);
+var Methods;
+(function(Methods2) {
+  Methods2.buildAsyncThunks = (onMethodRequest) => Object.fromEntries(Methods$1.MethodTypes.map((method) => [method, createAsyncThunk(method, (method2) => __async(this, 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;
-}, {});
+  }))]));
+})(Methods || (Methods = {}));
+var Events;
+(function(Events2) {
+  Events2.actions = Object.fromEntries(Events$1.EventTypes.map((event) => [event, createAction(event)]));
+})(Events || (Events = {}));
+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 = (alias2, methods) => (action) => methods[alias2](action.payload);
+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)
+});
+
+function handleMessage(message) {
+  const { type } = message;
+  if (type in Events$1.EventTypes) {
+    Events.actions[type](message);
+  }
+}
 
-const buildPlayerReducerCallback = (actions) => (builder) => {
-  builder.addCase(actions["player-runtime-info-request"].fulfilled, (state, action) => {
+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 +108,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 +123,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 +140,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 +152,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 +167,236 @@ const buildPlayerReducerCallback = (actions) => (builder) => {
     activePlayers[selectedPlayerId].profilerInfo = (_a = action.payload) == null ? void 0 : _a.data;
   });
 };
+const eventsReducer = (builder) => {
+  builder.addCase(Events.actions["player-init"], (state, action) => {
+    const {
+      payload: { version, playerID }
+    } = action;
+    state.activePlayers[playerID] = {
+      timelineEvents: [],
+      dataState: {},
+      consoleState: { history: [] }
+    };
+    state.version = version;
+  });
+  builder.addCase(Events.actions["player-removed"], (state, action) => {
+    delete state.activePlayers[action.payload.playerID];
+  });
+  builder.addCase(Events.actions["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(Events.actions["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;
+    }
+    activePlayers[selectedPlayerId].timelineEvents = [];
+  });
+  builder.addCase(Actions["clear-store"], () => {
+    return initialState;
+  });
+};
+const playersReducer = (methods) => createReducer(initialState, (builder) => {
+  actionsReducer(builder);
+  eventsReducer(builder);
+  methodsReducer(methods)(builder);
+});
 
-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({
+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 listenerMiddleware = createListenerMiddleware();
+listenerMiddleware.startListening({
+  matcher: isAnyOf(Events.actions["player-data-change-event"], Events.actions["player-log-event"], Events.actions["player-flow-start"], Events.actions["player-view-update-event"]),
+  effect: (action, api) => {
+    api.dispatch(Actions["player-timeline-event"](action.payload));
+  }
+});
+listenerMiddleware.startListening({
+  actionCreator: Events.actions["runtime-init"],
+  effect: (_, api) => {
+    api.dispatch(Actions["clear-store"]());
+  }
+});
+listenerMiddleware.startListening({
+  matcher: isAnyOf(Events.actions["player-init"], Events.actions["player-removed"]),
+  effect: (_, api) => {
+    api.dispatch(Actions["selected-player"]());
+  }
+});
+listenerMiddleware.startListening({
+  matcher: isAnyOf(Events.actions["player-flow-start"], Events.actions["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: message.playerID, binding: "" }
+        payload: { playerID, binding: players.activePlayers[playerID].dataState.selectedBinding }
       });
-      store.dispatch(playerTimelineAction(message));
-      break;
     }
-    default:
-      console.warn(`Unhandled event: ${JSON.stringify(message)}`);
-      break;
+    api.dispatch({
+      type: GET_DATA_BINDING_DETAILS,
+      payload: { playerID, binding: "" }
+    });
   }
-}
+});
 
-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 createDevtoolsStore = (onMethodRequest, middleware, additionalReducers) => configureStore({
+  reducer: __spreadValues({
+    players: playersReducer(Methods.buildAsyncThunks(onMethodRequest))
+  }, additionalReducers),
+  middleware: (getDefaultMiddleware) => {
+    const m = getDefaultMiddleware().concat(listenerMiddleware.middleware);
+    if (middleware)
+      m.prepend(middleware);
+    return m;
+  }
+});
 
-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, Events, GET_CONFIG_DETAILS, GET_CONSOLE_EVAL, GET_DATA_BINDING_DETAILS, GET_INFO_DETAILS, GET_VIEW_DETAILS, Methods, START_PROFILER, STOP_PROFILER, actionsReducer, buildAliases, createDevtoolsStore, eventsReducer, handleMessage, methodsReducer, 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.1",
+  "version": "0.2.2--canary.17.363",
   "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.1",
+    "@player-tools/devtools-common": "0.2.2--canary.17.363",
     "@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.ts

@@ -1,38 +1,82 @@
-import { type AsyncThunk, createAsyncThunk } from '@reduxjs/toolkit';
+import { type AsyncThunk, createAsyncThunk, AnyAction } from '@reduxjs/toolkit';
+import {
+  createAction,
+  ActionCreatorWithPayload,
+} from '@reduxjs/toolkit';
 import {
-  Runtime,
   createLogger,
   BACKGROUND_SOURCE,
+  // TODO: This is where being able to import the `Runtime` namespace is beneficial
+  Methods as RuntimeMethods,
+  Events as RuntimeEvents,
 } from '@player-tools/devtools-common';
-import type { RuntimeRPCRequestHandlers } from '../rpc';
 
 const logger = createLogger(BACKGROUND_SOURCE);
 
-export type AsyncRPCActions = {
-  [key in Runtime.RuntimeRPCTypes]: AsyncThunk<
-    Extract<Runtime.RuntimeRPC, { type: key }>['result'],
-    Extract<Runtime.RuntimeRPC, { type: key }>['params'],
-    any
-  >;
-};
+export namespace Methods {
+
+  /** Type describing an object containing async thunks for each Method defined */
+  export type MethodThunks = {
+    [key in RuntimeMethods.Method["type"]]: AsyncThunk<
+      RuntimeMethods.ByType<key>['result'],
+      RuntimeMethods.ByType<key>,
+      any
+    >;
+  };
+
+  export type MethodHandler = <T extends RuntimeMethods.MethodTypes>(
+    method: RuntimeMethods.ByType<T>
+  ) => Promise<RuntimeMethods.ByType<T>['result']>;
+
+  export const buildAsyncThunks = (
+    onMethodRequest: MethodHandler
+  ): MethodThunks => Object.fromEntries(
+    RuntimeMethods.MethodTypes.map(method => 
+      [method, createAsyncThunk<
+        RuntimeMethods.ByType<typeof method>['result'],
+        RuntimeMethods.ByType<typeof method>
+      >(method, async (method) => {
+        logger.log(`Requesting ${method.type}`, method.params);
+        const data = (await onMethodRequest(method)) as 
+          RuntimeMethods.ByType<typeof method.type>['result'];
+        logger.log(`Response from ${method.type}`, data);
+        return data;
+      })]
+    )
+  ) as MethodThunks
+}
+
+// TODO: What the hell should we do here? merged namespace for Events or new namespace?
+export namespace Events {
 
-export const buildRPCActions = (
-  handlers: RuntimeRPCRequestHandlers
-): AsyncRPCActions =>
-  Runtime.RuntimeRPCTypes.reduce((acc, rpcType) => {
-    // TODO: Fix this
-    // @ts-ignore
-    acc[rpcType] = createAsyncThunk<
-      Extract<Runtime.RuntimeRPC, { type: typeof rpcType }>['result'],
-      Extract<Runtime.RuntimeRPC, { type: typeof rpcType }>['params']
-    >(rpcType, async (params) => {
-      logger.log(`Requesting ${rpcType}`, params);
-      const data = (await handlers[rpcType].call(params)) as Extract<
-        Runtime.RuntimeRPC,
-        { type: typeof rpcType }
-      >['result'];
-      logger.log(`Response from ${rpcType}`, data);
-      return data;
-    });
-    return acc;
-  }, {} as AsyncRPCActions);
+  /** Redux actions associated against all possible event types */
+  type EventActions = {
+    [key in RuntimeEvents.EventTypes]: ActionCreatorWithPayload<
+      RuntimeEvents.ByType<key>,
+      key
+    >;
+  };
+
+  export interface EventAction<T extends RuntimeEvents.EventTypes = RuntimeEvents.EventTypes> extends AnyAction {
+    payload: RuntimeEvents.ByType<T>;
+  }
+
+  /** Redux actions associated against all defined event types */
+  export const actions: EventActions = Object.fromEntries(
+    RuntimeEvents.EventTypes.map(event => 
+      [event, createAction<RuntimeEvents.ByType<typeof event>>(event)]
+    )
+  ) as EventActions
+}
+
+export const Actions = {
+  // Explicit actions TODO: Is this level of redundancy okay?
+  'selected-player': createAction<string | undefined>('selected-player'),
+  'player-timeline-event': createAction<RuntimeEvents.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/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 type { Methods as RuntimeMethods } from '@player-tools/devtools-common';
+import { Methods } from './actions';
 
 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';
 
+
+export interface MethodAction<T extends RuntimeMethods.MethodTypes> {
+  payload: RuntimeMethods.ByType<T>;
+}
+
+// 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,15 @@ const _alias = (aliases: any) => () => (next: any) => (action: any) => {
   return next(action);
 };
 
-export const buildAliases = (actions: AsyncRPCActions) =>
+const alias = <T extends RuntimeMethods.MethodTypes>(alias: T, methods: Methods.MethodThunks) => (action: MethodAction<T>) => methods[alias](action.payload)
+
+export const buildAliases = (methods: 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),
   });