tidying up, making the data model a bit more structured,

modules/mod/src/main/typescript/events.ts

@@ -4,9 +4,6 @@
 // declare const factorioData: Data
 // declare const factorioMods: Mods
 
-// const eventEnum = {
-//   thingType: Object.values(defines.events)
-// }
 
 import {Serdes} from "./serdes/serdes"
 import {FactorioEvent, JsonTable} from "./model/model";
@@ -16,13 +13,10 @@ for (const [k, v] of pairs(defines.events)) {
   mapEventIdToName.set(v, k)
 }
 
-// function createFactorioEvent(tick: uint, object_name: string, eventType: string, data:
-// JsonTable): FactorioEvent { return { tick, object_name, eventType, data, } }
-
 function handlePlayerUpdate(tick: uint, playerIndex: uint, eventType: string) {
   let player: LuaPlayer = game.players[playerIndex]
   let table = Serdes.Player.playerToTable(player)
-  let event = FactorioEvent(tick, player.object_name, eventType, table)
+  let event = FactorioEvent(tick, eventType, table)
   emitEvent(event)
 
   handleCharactersEvent(tick, playerIndex, eventType)
@@ -44,13 +38,13 @@ function handleCharactersEvent(tick: uint, playerIndex: uint, eventType: string)
 
 function handleEntityUpdate(tick: uint, entity: LuaEntity, eventType: string) {
   let table = Serdes.Entity.entityToTable(entity)
-  let event = FactorioEvent(tick, entity.object_name, eventType, table)
+  let event = FactorioEvent(tick, eventType, table)
   emitEvent(event)
 }
 
 function surfaceEvent(tick: uint, surface: LuaSurface, eventType: string) {
   let table = Serdes.Surface.surfaceToTable(surface)
-  let event = FactorioEvent(tick, surface.object_name, eventType, table)
+  let event = FactorioEvent(tick, eventType, table)
   emitEvent(event)
 }
 

modules/mod/src/main/typescript/model/model.ts

@@ -1,3 +1,6 @@
+import {Serdes} from "../serdes/serdes";
+import FactorioObjectData = Serdes.FactorioObjectData;
+
 export type JsonPrimitiveType = number | string | boolean | undefined | null | void
 
 export type JsonArray<T extends JsonPrimitiveType = void> = T[]
@@ -22,18 +25,37 @@ export interface FactorioEvent extends JsonTable {
   tick: uint,
   /** the initial Factorio event ({defines.events}) trigger */
   event_type: string,
-  /** Defines the structure of {FactorioEvent.data} */
+  data: FactorioObjectData,
-  object_name: string,
-  data: JsonTable,
 }
 
-export const FactorioEvent = ((tick: uint, objectName: string, eventType: string, data: JsonTable) => {
+export const FactorioEvent =
-      return {
+    (<DataType extends FactorioObjectData>(
-        mod_version: MOD_VERSION,
+            tick: uint,
-        tick: tick,
+            eventType: string,
-        object_name: objectName,
+            data: DataType
-        event_type: eventType,
+        ) => {
-        data: data,
+          return {
-      } as FactorioEvent
+            mod_version: MOD_VERSION,
-    }
+            tick: tick,
-)
+            event_type: eventType,
+            data: data,
+          } as FactorioEvent
+        }
+    )
+
+
+// export type JsonArray<TValue extends JsonPrimitiveType> = TValue[]
+// export class JsonArray extends Array<JsonPrimitiveTypes> {
+// }
+
+// export type JsonArray = Array<JsonPrimitiveTypes>
+// declare type  JsonArrayConstructor = (new  () => JsonArray)
+// declare const JsonArray: JsonArrayConstructor
+
+// export class JsonTable extends LuaTable<string, JsonTableValueType> {
+// }
+// export  type JsonTable = LuaTable<string, JsonTableValueType>
+// const JsonTable = () => new LuaTable<string, JsonTableValueType>()
+// export type JsonTableConstructor = (new  () => JsonTable)
+// declare const JsonTable: JsonTableConstructor
+

modules/mod/src/main/typescript/serdes/serdes.ts

@@ -1,28 +1,26 @@
-// export type JsonArray<TValue extends JsonPrimitiveType> = TValue[]
-// export class JsonArray extends Array<JsonPrimitiveTypes> {
-// }
-
-// export type JsonArray = Array<JsonPrimitiveTypes>
-// declare type  JsonArrayConstructor = (new  () => JsonArray)
-// declare const JsonArray: JsonArrayConstructor
-
-// export class JsonTable extends LuaTable<string, JsonTableValueType> {
-// }
-// export  type JsonTable = LuaTable<string, JsonTableValueType>
-// const JsonTable = () => new LuaTable<string, JsonTableValueType>()
-// export type JsonTableConstructor = (new  () => JsonTable)
-// declare const JsonTable: JsonTableConstructor
-
-
 import {JsonTable, JsonArray} from "../model/model";
 
+import PositionData = Serdes.DataClasses.PositionData;
+
 export namespace Serdes {
 
+  export interface FactorioObjectData extends JsonTable {
+    object_name: string
+  }
+
   export namespace Player {
 
-    export function playerToTable(player: LuaPlayer): JsonTable {
+    export interface PlayerData extends FactorioObjectData {
+      name: string
+      character_unit_number?: uint
+      associated_characters_unit_numbers: JsonArray<number>
+      position: PositionData
+    }
+
+    export function playerToTable(player: LuaPlayer): PlayerData {
       let charIds = Entity.entitiesToUnitNumbers(player.get_associated_characters())
       return {
+        object_name: player.object_name,
         name: player.name,
         character_unit_number: player.character?.unit_number,
         associated_characters_unit_numbers: charIds,
@@ -34,9 +32,21 @@ export namespace Serdes {
 
   export namespace Entity {
 
-    export function entityToTable(entity: LuaEntity): JsonTable {
+    interface EntityData extends FactorioObjectData {
+      name: string
+      type: string
+      active: boolean
+      health?: number
+      surface_index: int
+      unit_number?: number
+      position: PositionData
+      player_index?: number
+    }
 
-      let data: JsonTable = {
+    export function entityToTable(entity: LuaEntity): EntityData {
+
+      let data: EntityData = {
+        object_name: entity.object_name,
         name: entity.name,
         type: entity.type,
         active: entity.active,
@@ -68,8 +78,15 @@ export namespace Serdes {
 
   export namespace Surface {
 
-    export function surfaceToTable(surface: LuaSurface): JsonTable {
+    interface SurfaceData extends FactorioObjectData {
+      name: string
+      index: uint
+      daytime: number
+    }
+
+    export function surfaceToTable(surface: LuaSurface): SurfaceData {
       return {
+        object_name: surface.object_name,
         name: surface.name,
         index: surface.index,
         daytime: surface.daytime,
@@ -80,7 +97,12 @@ export namespace Serdes {
 
   export namespace DataClasses {
 
-    export function positionTableToTable(positionTable: PositionTable): JsonTable {
+    export interface PositionData extends JsonTable {
+      x: int
+      y: int
+    }
+
+    export function positionTableToTable(positionTable: PositionTable): PositionData {
       return {
         x: positionTable.x,
         y: positionTable.y,