@defold-typescript/transpiler 0.48.0 → 0.49.0

package/dist/hsm/debug.ts

@@ -19,8 +19,15 @@ const SILENT: MachineInspector = {
 
 const TEXT_OFFSET_Y = 40;
 
-const labelUses: Record<string, number> = {};
-const issuedLabels: Record<string, boolean> = {};
+// A JavaScript object inherits members such as `__proto__` and `constructor`, and a caller's
+// string can name one. This literal has no prototype, so every string is an own key. In Lua the
+// nil field leaves a plain table.
+function record<V>(): Record<string, V> {
+  return { __proto__: null } as unknown as Record<string, V>;
+}
+
+const labelUses = record<number>();
+const issuedLabels = record<boolean>();
 
 function uniqueLabel(label: string): string {
   let ordinal = labelUses[label] ?? 1;
@@ -96,9 +103,12 @@ function shownLeaves(leaves: readonly string[]): string {
 
 /**
  * Prints one line when it is called, then one line for each move `instance` makes, each starting
- * with `hsm` and the label. Call it once after `start`. A label another `inspect` call already
- * used gets an ordinal, such as `enemy#2`. In a release build it registers nothing and returns an
- * inspector whose `draw` does nothing, so the calls can stay in shipped code.
+ * with `hsm` and the label. A move's line names the state whose rule made it and that rule's key.
+ * An event no active state takes prints an `unhandled` line with its `type` and the active
+ * leaves, once per type until the next move. Call it once after `start`. A label another
+ * `inspect` call already used gets an ordinal, such as `enemy#2`. In a release build it registers
+ * nothing and returns an inspector whose `draw` does nothing, so the calls can stay in shipped
+ * code.
  */
 export function inspect<Ctx, E extends EventObject, P extends string>(
   instance: MachineInstance<Ctx, E, P>,
@@ -110,10 +120,28 @@ export function inspect<Ctx, E extends EventObject, P extends string>(
   const shownLabel = uniqueLabel(label);
   const loggedLabel = escapeField(shownLabel);
   let frame = 0;
-  instance.onMove((from, to, cause, event) => {
-    const reason = event === undefined ? cause : event.type;
+  let moves = 0;
+  const unhandledAt = record<number>();
+  instance.onMove((from, to, cause, event, source?: string, key?: number) => {
+    moves++;
+    let reason = escapeField(event === undefined ? cause : event.type);
+    if (source !== undefined) {
+      reason = `${reason}: ${escapeField(source)}`;
+      if (key !== undefined) {
+        reason = `${reason}, ${key}`;
+      }
+    }
+    print(
+      `hsm ${loggedLabel} frame ${frame}: ${escapeField(from)} -> ${shown(to)} (${reason}) [${shownList(instance.leaves, escapeField)}]`,
+    );
+  });
+  instance.onUnhandled((event) => {
+    if (unhandledAt[event.type] === moves) {
+      return;
+    }
+    unhandledAt[event.type] = moves;
     print(
-      `hsm ${loggedLabel} frame ${frame}: ${escapeField(from)} -> ${shown(to)} (${escapeField(reason)}) [${shownList(instance.leaves, escapeField)}]`,
+      `hsm ${loggedLabel} frame ${frame}: unhandled (${escapeField(event.type)}) [${shownList(instance.leaves, escapeField)}]`,
     );
   });
   print(