xstate 5.33.3 → 5.33.4

package/dist/xstate.cjs.js

@@ -9,9 +9,33 @@ var assign = require('./assign-76f14f49.cjs.js');
 var log = require('./log-81c55f77.cjs.js');
 require('./xstate-dev.cjs.js');
 
+// `AssertedEvent` is kept local to this module rather than reusing
+// `ExtractEvent` (types.ts) so that the narrowing also resolves when `TEvent` is
+// an unresolved generic type parameter, e.g.:
+//
+// function example<T extends SomeEventUnion>(event: T) {
+//   assertEvent(event, 'someType');
+//   event.someProp; // previously a type error; now narrows correctly
+// }
+//
+// Two details make that work while still matching what `ExtractEvent` does:
+//
+// 1. We match `{ type: infer TType }` and test the fresh `TType` parameter
+//    instead of indexing `TEvent['type']` inside the distribution over
+//    `TEvent`. Indexing a still-unresolved generic `TEvent` leaves the whole
+//    conditional opaque, so every property access on the "narrowed" event then
+//    fails.
+// 2. Testing the inferred `TType` also lets the descriptor check distribute
+//    over a union-typed `type` field, so an event like `{ type: 'a' | 'b' }` is
+//    still matched by the descriptor `'a'` (mirroring `ExtractEvent`'s
+//    `EventDescriptorMatches`). Plain assignability
+//    (`TEvent extends { type: 'a' }`) would instead throw such an event away.
+
 /**
  * Asserts that the given event object is of the specified type or types. Throws
  * an error if the event object is not of the specified types.
+ * Partial wildcard descriptors such as `feedback.*` match both `feedback` and
+ * its descendants, such as `feedback.good`.
  *
  * @example
  *

package/dist/xstate.development.cjs.js

@@ -9,9 +9,33 @@ var assign = require('./assign-6e49963c.development.cjs.js');
 var log = require('./log-ef4ad2a1.development.cjs.js');
 require('./xstate-dev.development.cjs.js');
 
+// `AssertedEvent` is kept local to this module rather than reusing
+// `ExtractEvent` (types.ts) so that the narrowing also resolves when `TEvent` is
+// an unresolved generic type parameter, e.g.:
+//
+// function example<T extends SomeEventUnion>(event: T) {
+//   assertEvent(event, 'someType');
+//   event.someProp; // previously a type error; now narrows correctly
+// }
+//
+// Two details make that work while still matching what `ExtractEvent` does:
+//
+// 1. We match `{ type: infer TType }` and test the fresh `TType` parameter
+//    instead of indexing `TEvent['type']` inside the distribution over
+//    `TEvent`. Indexing a still-unresolved generic `TEvent` leaves the whole
+//    conditional opaque, so every property access on the "narrowed" event then
+//    fails.
+// 2. Testing the inferred `TType` also lets the descriptor check distribute
+//    over a union-typed `type` field, so an event like `{ type: 'a' | 'b' }` is
+//    still matched by the descriptor `'a'` (mirroring `ExtractEvent`'s
+//    `EventDescriptorMatches`). Plain assignability
+//    (`TEvent extends { type: 'a' }`) would instead throw such an event away.
+
 /**
  * Asserts that the given event object is of the specified type or types. Throws
  * an error if the event object is not of the specified types.
+ * Partial wildcard descriptors such as `feedback.*` match both `feedback` and
+ * its descendants, such as `feedback.good`.
  *
  * @example
  *

package/dist/xstate.development.esm.js

@@ -9,9 +9,33 @@ import { s as sendTo, l as log, e as enqueueActions, a as emit } from './log-d16
 export { S as SpecialTargets, a as emit, e as enqueueActions, f as forwardTo, l as log, b as sendParent, s as sendTo } from './log-d1660d4b.development.esm.js';
 import './xstate-dev.development.esm.js';
 
+// `AssertedEvent` is kept local to this module rather than reusing
+// `ExtractEvent` (types.ts) so that the narrowing also resolves when `TEvent` is
+// an unresolved generic type parameter, e.g.:
+//
+// function example<T extends SomeEventUnion>(event: T) {
+//   assertEvent(event, 'someType');
+//   event.someProp; // previously a type error; now narrows correctly
+// }
+//
+// Two details make that work while still matching what `ExtractEvent` does:
+//
+// 1. We match `{ type: infer TType }` and test the fresh `TType` parameter
+//    instead of indexing `TEvent['type']` inside the distribution over
+//    `TEvent`. Indexing a still-unresolved generic `TEvent` leaves the whole
+//    conditional opaque, so every property access on the "narrowed" event then
+//    fails.
+// 2. Testing the inferred `TType` also lets the descriptor check distribute
+//    over a union-typed `type` field, so an event like `{ type: 'a' | 'b' }` is
+//    still matched by the descriptor `'a'` (mirroring `ExtractEvent`'s
+//    `EventDescriptorMatches`). Plain assignability
+//    (`TEvent extends { type: 'a' }`) would instead throw such an event away.
+
 /**
  * Asserts that the given event object is of the specified type or types. Throws
  * an error if the event object is not of the specified types.
+ * Partial wildcard descriptors such as `feedback.*` match both `feedback` and
+ * its descendants, such as `feedback.good`.
  *
  * @example
  *

package/dist/xstate.esm.js

@@ -9,9 +9,33 @@ import { s as sendTo, l as log, e as enqueueActions, a as emit } from './log-6a5
 export { S as SpecialTargets, a as emit, e as enqueueActions, f as forwardTo, l as log, b as sendParent, s as sendTo } from './log-6a5e50a8.esm.js';
 import './xstate-dev.esm.js';
 
+// `AssertedEvent` is kept local to this module rather than reusing
+// `ExtractEvent` (types.ts) so that the narrowing also resolves when `TEvent` is
+// an unresolved generic type parameter, e.g.:
+//
+// function example<T extends SomeEventUnion>(event: T) {
+//   assertEvent(event, 'someType');
+//   event.someProp; // previously a type error; now narrows correctly
+// }
+//
+// Two details make that work while still matching what `ExtractEvent` does:
+//
+// 1. We match `{ type: infer TType }` and test the fresh `TType` parameter
+//    instead of indexing `TEvent['type']` inside the distribution over
+//    `TEvent`. Indexing a still-unresolved generic `TEvent` leaves the whole
+//    conditional opaque, so every property access on the "narrowed" event then
+//    fails.
+// 2. Testing the inferred `TType` also lets the descriptor check distribute
+//    over a union-typed `type` field, so an event like `{ type: 'a' | 'b' }` is
+//    still matched by the descriptor `'a'` (mirroring `ExtractEvent`'s
+//    `EventDescriptorMatches`). Plain assignability
+//    (`TEvent extends { type: 'a' }`) would instead throw such an event away.
+
 /**
  * Asserts that the given event object is of the specified type or types. Throws
  * an error if the event object is not of the specified types.
+ * Partial wildcard descriptors such as `feedback.*` match both `feedback` and
+ * its descendants, such as `feedback.good`.
  *
  * @example
  *