[poc] Use a functionBrand to make limited callback actors possible

packages/core/src/types.ts

@@ -15,6 +15,16 @@ import {
   TypegenDisabled
 } from './typegenTypes.ts';
 
+type Primitive = string | number | boolean | symbol | bigint | null | undefined;
+
+declare const functionBrand: unique symbol;
+type NotAFunction<T> = T & { [functionBrand]?: never };
+declare global {
+  interface Function {
+    [functionBrand]?: true;
+  }
+}
+
 export type Identity<T> = { [K in keyof T]: T[K] };
 
 export type HomomorphicPick<T, K extends keyof any> = {
@@ -674,7 +684,9 @@ export type InvokeConfig<
 
       input?:
         | Mapper<TContext, TEvent, NonReducibleUnknown, TEvent>
-        | NonReducibleUnknown;
+        | Primitive
+        | NotAFunction<{ [k: PropertyKey]: unknown }>
+        | NotAFunction<object>;
       /**
        * The transition to take upon the invoked child machine reaching its final top-level state.
        */

packages/core/test/setup.types.test.ts

@@ -1,9 +1,11 @@
 import {
+  ActorRef,
   ActorRefFrom,
   and,
   assign,
   createActor,
   createMachine,
+  fromCallback,
   fromPromise,
   fromTransition,
   not,
@@ -1599,3 +1601,54 @@
     });
   });
 });
+
+type MyCustomEvents = 'MY_EVENT' | 'MY_OTHER_EVENT';
+
+type ParentAcceptingSimpleEvents<Event extends string> = ActorRef<
+  any,
+  { [K in Event]: { type: K } }[Event]
+>;
+
+const registerEvent = <Event extends MyCustomEvents>(eventName: Event) => ({
+  id: `listenerFor:${eventName}` as const,
+  src: fromCallback(
+    ({
+      sendBack
+    }: {
+      sendBack: ParentAcceptingSimpleEvents<Event>['send'];
+    }) => {
+      const handler = (event: CustomEventInit) =>
+        sendBack({
+          ...(event.detail ?? {}),
+          type: eventName
+        });
+
+      document.addEventListener(eventName, handler);
+      return () => {
+        document.removeEventListener(eventName, handler);
+      };
+    }
+  ),
+  input: ({ self }: { self: ParentAcceptingSimpleEvents<Event> }) => ({
+    parent: self
+  })
+});
+
+createMachine({
+  types: {
+    events: {} as { type: 'MY_EVENT' }
+  },
+  invoke: registerEvent('MY_EVENT'),
+  on: {
+    MY_EVENT: {
+      actions: 'myAction'
+    }
+  }
+});
+
+createMachine({
+  types: {
+    events: {} as { type: 'DIFFERENT_EVENT' }
+  },
+  invoke: registerEvent('MY_EVENT')
+});