@defold-typescript/transpiler 0.43.0 → 0.44.0

package/dist/hsm/async.ts

@@ -0,0 +1,73 @@
+import type { EventObject, TaskStart } from "./index";
+
+/** @noSelf */
+export interface SequenceSignal {
+  readonly aborted: boolean;
+  readonly wait: (seconds: number) => Promise<void>;
+}
+
+/** @noSelf */
+interface Signal {
+  aborted: boolean;
+  readonly wait: (seconds: number) => Promise<void>;
+}
+
+function forget(handles: number[], handle: number): void {
+  for (let i = 0; i < handles.length; i++) {
+    if (handles[i] === handle) {
+      handles[i] = handles[handles.length - 1] as number;
+      handles.pop();
+      return;
+    }
+  }
+}
+
+// A rejected sequence promise has no reader, so its error would vanish; a fresh
+// timer callback raises it where the engine logs it.
+function rethrow(reason: unknown): void {
+  timer.delay(0, false, () => {
+    throw reason;
+  });
+}
+
+// The sequence plugs into the state's task, so its cleanup cancels the pending
+// waits on every way out of the state; a wait left pending is never resolved.
+export function sequence<Ctx, E extends EventObject>(
+  // biome-ignore lint/suspicious/noConfusingVoidType: `void` lets a sequence end without returning an event.
+  run: (ctx: Ctx, signal: SequenceSignal) => Promise<NoInfer<E> | void>,
+): TaskStart<Ctx, E> {
+  return (ctx, finish) => {
+    const handles: number[] = [];
+    const signal: Signal = {
+      aborted: false,
+      wait: (seconds) =>
+        new Promise<void>((resolve) => {
+          if (signal.aborted) {
+            return;
+          }
+          handles.push(
+            timer.delay(seconds, false, (_self, handle) => {
+              forget(handles, handle);
+              if (!signal.aborted) {
+                resolve();
+              }
+            }),
+          );
+        }),
+    };
+    run(ctx, signal).then(
+      (event) => {
+        if (event !== undefined) {
+          finish(event);
+        }
+      },
+      (reason) => rethrow(reason),
+    );
+    return () => {
+      signal.aborted = true;
+      while (handles.length > 0) {
+        timer.cancel(handles.pop() as number);
+      }
+    };
+  };
+}

package/dist/hsm/debug.ts

@@ -0,0 +1,119 @@
+import type { EventObject, MachineInstance } from "./index";
+
+/** @noSelf */
+export interface MachineInspector {
+  readonly draw: (target: Hash | Url | string) => void;
+}
+
+const SILENT: MachineInspector = {
+  draw: () => {},
+};
+
+const TEXT_OFFSET_Y = 40;
+
+const labelUses: Record<string, number> = {};
+const issuedLabels: Record<string, boolean> = {};
+
+function uniqueLabel(label: string): string {
+  let ordinal = labelUses[label] ?? 1;
+  let issued = label;
+  while (issuedLabels[issued] === true) {
+    ordinal++;
+    issued = `${label}#${ordinal}`;
+  }
+  labelUses[label] = ordinal;
+  issuedLabels[issued] = true;
+  return issued;
+}
+
+const FIELD_ESCAPES: Record<string, string> = {
+  "\\": "\\\\",
+  "[": "\\[",
+  "]": "\\]",
+  "(": "\\(",
+  ")": "\\)",
+  ",": "\\,",
+  ">": "\\>",
+  ":": "\\:",
+  "\n": "\\n",
+  "\r": "\\r",
+};
+
+// A structural cast keeps each read a plain method call: native in JavaScript, string.sub in Lua.
+interface StringChars {
+  charAt(index: number): string;
+  sub(first: number, last: number): string;
+}
+
+// JavaScript strings hold UTF-16 code units; Lua strings hold UTF-8 bytes. Every escaped
+// character is ASCII, and ASCII never occurs inside a UTF-8 sequence, so both walks agree.
+const UTF16_UNITS = "\u{E000}".length === 1;
+
+function charAt(text: string, index: number): string {
+  const chars = text as unknown as StringChars;
+  return UTF16_UNITS ? chars.charAt(index) : chars.sub(index + 1, index + 1);
+}
+
+function escapeField(text: string): string {
+  let escaped = "";
+  for (let i = 0; i < text.length; i++) {
+    const char = charAt(text, i);
+    escaped = `${escaped}${FIELD_ESCAPES[char] ?? char}`;
+  }
+  return escaped;
+}
+
+function raw(text: string): string {
+  return text;
+}
+
+function shown(path: string | undefined): string {
+  return path === undefined ? "(stopped)" : escapeField(path);
+}
+
+function shownList(leaves: readonly string[], show: (leaf: string) => string): string {
+  if (leaves.length === 0) {
+    return "";
+  }
+  let text = show(leaves[0] as string);
+  for (let i = 1; i < leaves.length; i++) {
+    text = `${text}, ${show(leaves[i] as string)}`;
+  }
+  return text;
+}
+
+function shownLeaves(leaves: readonly string[]): string {
+  return leaves.length === 0 ? "(stopped)" : shownList(leaves, raw);
+}
+
+export function inspect<Ctx, E extends EventObject, P extends string>(
+  instance: MachineInstance<Ctx, E, P>,
+  label: string,
+): MachineInspector {
+  if (!sys.get_engine_info().is_debug) {
+    return SILENT;
+  }
+  const shownLabel = uniqueLabel(label);
+  const loggedLabel = escapeField(shownLabel);
+  let frame = 0;
+  instance.onMove((from, to, cause, event) => {
+    const reason = event === undefined ? cause : event.type;
+    print(
+      `hsm ${loggedLabel} frame ${frame}: ${escapeField(from)} -> ${shown(to)} (${escapeField(reason)}) [${shownList(instance.leaves, escapeField)}]`,
+    );
+  });
+  print(
+    `hsm ${loggedLabel} frame ${frame}: inspecting [${shownList(instance.leaves, escapeField)}]`,
+  );
+  return {
+    draw: (target) => {
+      frame++;
+      const p = go.get_world_position(target);
+      msg.post("@render:", "draw_debug_text", {
+        text: `${shownLabel} ${shownLeaves(instance.leaves)}`,
+        position: vmath.vector3(p.x, p.y + TEXT_OFFSET_Y, p.z),
+        color: vmath.vector4(1, 1, 1, 1),
+      });
+    },
+  };
+}

package/dist/hsm/defold.ts

@@ -1,5 +1,5 @@
 export type MessageEvent<K extends MessageId> = K extends MessageId
-  ? { readonly type: K } & Omit<MessagePayload<K>, "type">
+  ? { readonly type: K; readonly sender: Url } & Omit<MessagePayload<K>, "type" | "sender">
   : never;
 
 /** @noSelf */
@@ -7,6 +7,7 @@ export interface MessageEventMapper<K extends MessageId> {
   readonly toEvent: (
     message_id: Hash,
     message: Record<string | number, unknown>,
+    sender: Url,
   ) => MessageEvent<K> | undefined;
 }
 
@@ -16,18 +17,23 @@ export function messageEvents<const K extends MessageId>(ids: readonly K[]): Mes
     hashes[i] = hash(ids[i] as K);
   }
   return {
-    toEvent: (message_id, message) => {
+    toEvent: (message_id, message, sender) => {
       for (let i = 0; i < hashes.length; i++) {
         if (hashes[i] === message_id) {
-          const event: { [key: string]: unknown } = {};
-          for (const key in message) {
-            event[key] = message[key];
-          }
-          event.type = ids[i];
-          return event as unknown as MessageEvent<K>;
+          return copyEvent(ids[i] as K, message, sender) as MessageEvent<K>;
         }
       }
       return undefined;
     },
   };
 }
+
+function copyEvent(type: string, message: Record<string | number, unknown>, sender: Url): unknown {
+  const event: { [key: string]: unknown } = {};
+  for (const key in message) {
+    event[key] = message[key];
+  }
+  event.type = type;
+  event.sender = sender;
+  return event;
+}