@xmachines/play-xstate 3.0.0 → 4.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmachines/play-xstate",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "description": "XState v5 adapter for Play Architecture",
   "keywords": [
     "actor-model",
@@ -10,7 +10,7 @@
     "xstate"
   ],
   "license": "MIT",
-  "author": "",
+  "author": "XMachines Contributors",
   "repository": {
     "type": "git",
     "url": "git+https://gitlab.com/xmachin-es/xmachines-js.git",
@@ -30,6 +30,14 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./routing": {
+      "types": "./dist/with-routing.d.ts",
+      "default": "./dist/with-routing.js"
+    },
+    "./view": {
+      "types": "./dist/with-view.d.ts",
+      "default": "./dist/with-view.js"
+    },
     "./errors": {
       "types": "./dist/errors.d.ts",
       "default": "./dist/errors.js"
@@ -43,33 +51,46 @@
     "build": "vite build && tsc --build",
     "clean": "rm -rf dist *.tsbuildinfo coverage node_modules/.svelte2tsx-* node_modules/.vite*",
     "lint": "oxlint .",
+    "lint:security": "node ../../scripts/semgrep-scan.mjs",
     "format": "oxfmt .",
     "test": "vitest",
     "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
-    "@xmachines/play": "3.0.0",
-    "@xmachines/play-actor": "3.0.0",
-    "@xmachines/play-signals": "3.0.0",
-    "dequal": "^2.0.3"
+    "@xmachines/play-actor": "4.0.0"
   },
   "devDependencies": {
-    "@testing-library/jest-dom": "^6.9.1",
-    "@types/node": "^26.2.0",
+    "@testing-library/jest-dom": "^7.0.1",
+    "@types/node": "^26.6.2",
     "@xmachines/json-render-core": "^0.20.0-xm.4",
-    "@xmachines/play-router": "3.0.0",
-    "oxfmt": "^0.64.0",
-    "oxlint": "^1.79.0",
+    "@xmachines/play": "4.0.0",
+    "@xmachines/play-router": "4.0.0",
+    "@xmachines/play-signals": "4.0.0",
+    "@xmachines/play-view": "4.0.0",
+    "oxfmt": "^0.68.0",
+    "oxlint": "^1.83.0",
     "typescript": "^5.9.3 || ^6.0.3",
-    "vite": "^8.0.10",
-    "vitest": "^4.1.11",
-    "xstate": "^5.31.0"
+    "vite": "^8.3.0",
+    "vitest": "^5.0.1",
+    "xstate": "^5.33.0"
   },
   "peerDependencies": {
-    "xstate": "^5.31.0"
+    "@xmachines/play": "4.0.0",
+    "@xmachines/play-router": "4.0.0",
+    "@xmachines/play-signals": "4.0.0",
+    "@xmachines/play-view": "4.0.0",
+    "xstate": "^5.33.0"
+  },
+  "peerDependenciesMeta": {
+    "@xmachines/play-view": {
+      "optional": true
+    },
+    "@xmachines/play-router": {
+      "optional": true
+    }
   },
   "engines": {
-    "node": ">=22.0.0"
+    "node": ">=24.0.0"
   },
-  "_devDependencies_note": "xstate appears in both peerDependencies and devDependencies intentionally. devDependencies provides workspace resolution for local builds, tests, and typechecking. peerDependencies declares the consumer version constraint. Both are pinned to ^5.30.0 to prevent drift."
+  "_devDependencies_note": "xstate appears in both peerDependencies and devDependencies intentionally. devDependencies provides workspace resolution for local builds, tests, and typechecking. peerDependencies declares the consumer version constraint. Both hold the same range, to prevent drift."
 }

package/dist/guards/compose.d.ts

@@ -1,158 +0,0 @@
-import type { GuardPredicate } from "xstate";
-import type { Guard, GuardArray } from "./types.js";
-import type { MachineContext, EventObject, ParameterizedObject } from "xstate";
-/**
- * The narrowest public return type of the guard composition helpers.
- *
- * `GuardPredicate<MachineContext, EventObject, unknown, ParameterizedObject>` is the
- * concrete XState guard type with the widest compatibility that uses no `any`.
- *
- * @public
- * @deprecated The next major version removes the guard utilities. Use the
- * combinator types of XState directly.
- */
-export type ComposedGuard = GuardPredicate<MachineContext, EventObject, unknown, ParameterizedObject>;
-/**
- * Composes the guards with the AND logic, through the and() helper of XState
- *
- * The function joins more than one guard predicate with the AND semantics: every
- * guard must pass, and the composition then succeeds. It uses the built-in `and()`
- * helper of XState. The type inference and the serialization of the machine are
- * therefore correct.
- *
- * **Architectural context:** the function supports **Actor Authority (INV-01)**,
- * because it composes the guards of a state machine transition declaratively. A
- * guard enforces a rule of the business logic, and that rule decides if a
- * navigation or an action is valid.
- *
- * @typeParam TContext - The context type of the state machine
- * @typeParam TEvent - The event type
- *
- * @param guards - The array of the guard predicates, or of the guard names as strings
- * @returns The and() guard composition of XState
- *
- * @throws {Error} When the array of the guards is empty
- *
- * @example
- * An AND composition with named guards
- * ```typescript
- * import { setup } from "xstate";
- * import { composeGuards } from "@xmachines/play-xstate";
- *
- * const machine = setup({
- *   guards: {
- *     isLoggedIn: ({ context }) => !!context.userId,
- *     hasPermission: ({ context }) => context.permissions.includes('admin'),
- *   }
- * }).createMachine({
- *   on: {
- *     accessAdmin: {
- *       // Both guards must pass
- *       guard: composeGuards(['isLoggedIn', 'hasPermission']),
- *       target: 'adminPanel'
- *     }
- *   }
- * });
- * ```
- *
- * @example
- * An AND composition with inline predicates
- * ```typescript
- * import { composeGuards } from "@xmachines/play-xstate";
- *
- * guard: composeGuards([
- *   ({ context }) => context.age >= 18,
- *   ({ context }) => context.verified
- * ])
- * ```
- *
- * @see {@link composeGuardsOr} for the OR composition
- * @see {@link negateGuard} for the NOT logic
- * @deprecated Use the `and()`, `or()`, and `not()` combinators of XState directly. This helper
- * does not compose with a guard slot that `setup()` types, and the next major version removes it.
- */
-export declare const composeGuards: <TContext = any, TEvent = any>(guards: GuardArray<TContext, TEvent>) => ComposedGuard;
-/**
- * Composes the guards with the OR logic, through the or() helper of XState
- *
- * The function joins more than one guard predicate with the OR semantics: one guard
- * must pass at least, and the composition then succeeds. It uses the built-in `or()`
- * helper of XState, and the type inference is therefore correct.
- *
- * @typeParam TContext - The context type of the state machine
- * @typeParam TEvent - The event type
- *
- * @param guards - The array of the guard predicates, or of the guard names
- * @returns The or() guard composition of XState
- *
- * @throws {Error} When the array of the guards is empty
- *
- * @example
- * An OR composition with named guards
- * ```typescript
- * import { setup } from "xstate";
- * import { composeGuardsOr } from "@xmachines/play-xstate";
- *
- * const machine = setup({
- *   guards: {
- *     isOwner: ({ context }) => context.role === 'owner',
- *     isAdmin: ({ context }) => context.role === 'admin'
- *   }
- * }).createMachine({
- *   on: {
- *     deleteResource: {
- *       // One guard is sufficient
- *       guard: composeGuardsOr(['isOwner', 'isAdmin']),
- *       actions: 'delete'
- *     }
- *   }
- * });
- * ```
- *
- * @see {@link composeGuards} for the AND composition
- * @see {@link negateGuard} for the NOT logic
- * @deprecated Use the `and()`, `or()`, and `not()` combinators of XState directly. This helper
- * does not compose with a guard slot that `setup()` types, and the next major version removes it.
- */
-export declare const composeGuardsOr: <TContext = any, TEvent = any>(guards: GuardArray<TContext, TEvent>) => ComposedGuard;
-/**
- * Negates a guard, through the not() helper of XState
- *
- * The function inverts the result of a guard: the guard passes, and NOT then fails;
- * the guard fails, and NOT then passes. It uses the built-in `not()` helper of
- * XState, and the serialization is therefore correct.
- *
- * @typeParam TContext - The context type of the state machine
- * @typeParam TEvent - The event type
- *
- * @param guard - The guard predicate to negate, or its name
- * @returns The not() guard negation of XState
- *
- * @example
- * A NOT composition with a named guard
- * ```typescript
- * import { setup } from "xstate";
- * import { negateGuard } from "@xmachines/play-xstate";
- *
- * const machine = setup({
- *   guards: {
- *     isGuest: ({ context }) => !context.userId
- *   }
- * }).createMachine({
- *   on: {
- *     accessDashboard: {
- *       // Permit the transition when the user is NOT a guest, which means an authenticated user
- *       guard: negateGuard('isGuest'),
- *       target: 'dashboard'
- *     }
- *   }
- * });
- * ```
- *
- * @see {@link composeGuards} for the AND composition
- * @see {@link composeGuardsOr} for the OR composition
- * @deprecated Use the `and()`, `or()`, and `not()` combinators of XState directly. This helper
- * does not compose with a guard slot that `setup()` types, and the next major version removes it.
- */
-export declare const negateGuard: <TContext = any, TEvent = any>(guard: Guard<TContext, TEvent> | string) => ComposedGuard;
-//# sourceMappingURL=compose.d.ts.map

package/dist/guards/compose.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../src/guards/compose.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AAmB/E;;;;;;;;;GASG;AACH,MAAM,MAAM,aAAa,GAAG,cAAc,CACzC,cAAc,EACd,WAAW,EACX,OAAO,EACP,mBAAmB,CACnB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAEH,eAAO,MAAM,aAAa,GAAI,QAAQ,GAAG,GAAG,EAAE,MAAM,GAAG,GAAG,EACzD,QAAQ,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,KAClC,aAYF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,eAAO,MAAM,eAAe,GAAI,QAAQ,GAAG,GAAG,EAAE,MAAM,GAAG,GAAG,EAC3D,QAAQ,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,KAClC,aAYF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,eAAO,MAAM,WAAW,GAAI,QAAQ,GAAG,GAAG,EAAE,MAAM,GAAG,GAAG,EACvD,OAAO,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,MAAM,KACrC,aAIF,CAAC"}

package/dist/guards/compose.js

@@ -1,188 +0,0 @@
-import { and, or, not } from "xstate";
-import { EmptyGuardArrayError } from "../errors.js";
-/**
- * The one unsound boundary of the PRODUCTION code, and it covers the guard types of
- * XState only. (The test code uses `unsafeCast` from
- * `@xmachines/shared/test-support` instead. The two functions are counterparts, and
- * an audit of the casts with grep must cover both names.)
- *
- * These deprecated helpers close two known gaps in the types of XState 5.28. In the
- * first gap, our `Guard<TContext, TEvent>` type does not match `ComposedGuard`
- * structurally, because the event generic is different. In the second gap, `and()`
- * and `or()` need a `readonly [...tuple]`, and `GuardArray` is a mutable array. The
- * values at run time are identical in each case. The parameter has the type
- * `unknown`. Therefore one `as` cast is here, and no call site needs a double cast.
- * Follow the improvements of the XState types: https://github.com/statelyai/xstate/issues
- */
-const asXStateGuard = (value) => value;
-/**
- * Composes the guards with the AND logic, through the and() helper of XState
- *
- * The function joins more than one guard predicate with the AND semantics: every
- * guard must pass, and the composition then succeeds. It uses the built-in `and()`
- * helper of XState. The type inference and the serialization of the machine are
- * therefore correct.
- *
- * **Architectural context:** the function supports **Actor Authority (INV-01)**,
- * because it composes the guards of a state machine transition declaratively. A
- * guard enforces a rule of the business logic, and that rule decides if a
- * navigation or an action is valid.
- *
- * @typeParam TContext - The context type of the state machine
- * @typeParam TEvent - The event type
- *
- * @param guards - The array of the guard predicates, or of the guard names as strings
- * @returns The and() guard composition of XState
- *
- * @throws {Error} When the array of the guards is empty
- *
- * @example
- * An AND composition with named guards
- * ```typescript
- * import { setup } from "xstate";
- * import { composeGuards } from "@xmachines/play-xstate";
- *
- * const machine = setup({
- *   guards: {
- *     isLoggedIn: ({ context }) => !!context.userId,
- *     hasPermission: ({ context }) => context.permissions.includes('admin'),
- *   }
- * }).createMachine({
- *   on: {
- *     accessAdmin: {
- *       // Both guards must pass
- *       guard: composeGuards(['isLoggedIn', 'hasPermission']),
- *       target: 'adminPanel'
- *     }
- *   }
- * });
- * ```
- *
- * @example
- * An AND composition with inline predicates
- * ```typescript
- * import { composeGuards } from "@xmachines/play-xstate";
- *
- * guard: composeGuards([
- *   ({ context }) => context.age >= 18,
- *   ({ context }) => context.verified
- * ])
- * ```
- *
- * @see {@link composeGuardsOr} for the OR composition
- * @see {@link negateGuard} for the NOT logic
- * @deprecated Use the `and()`, `or()`, and `not()` combinators of XState directly. This helper
- * does not compose with a guard slot that `setup()` types, and the next major version removes it.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const composeGuards = (guards) => {
-    if (guards.length === 0) {
-        throw new EmptyGuardArrayError("and");
-    }
-    if (guards.length === 1) {
-        // One guard passes through. asXStateGuard gives the reason for the boundary.
-        return asXStateGuard(guards[0]);
-    }
-    // Use the built-in and() of XState, for the type inference and the serialization.
-    return and(asXStateGuard(guards));
-};
-/**
- * Composes the guards with the OR logic, through the or() helper of XState
- *
- * The function joins more than one guard predicate with the OR semantics: one guard
- * must pass at least, and the composition then succeeds. It uses the built-in `or()`
- * helper of XState, and the type inference is therefore correct.
- *
- * @typeParam TContext - The context type of the state machine
- * @typeParam TEvent - The event type
- *
- * @param guards - The array of the guard predicates, or of the guard names
- * @returns The or() guard composition of XState
- *
- * @throws {Error} When the array of the guards is empty
- *
- * @example
- * An OR composition with named guards
- * ```typescript
- * import { setup } from "xstate";
- * import { composeGuardsOr } from "@xmachines/play-xstate";
- *
- * const machine = setup({
- *   guards: {
- *     isOwner: ({ context }) => context.role === 'owner',
- *     isAdmin: ({ context }) => context.role === 'admin'
- *   }
- * }).createMachine({
- *   on: {
- *     deleteResource: {
- *       // One guard is sufficient
- *       guard: composeGuardsOr(['isOwner', 'isAdmin']),
- *       actions: 'delete'
- *     }
- *   }
- * });
- * ```
- *
- * @see {@link composeGuards} for the AND composition
- * @see {@link negateGuard} for the NOT logic
- * @deprecated Use the `and()`, `or()`, and `not()` combinators of XState directly. This helper
- * does not compose with a guard slot that `setup()` types, and the next major version removes it.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const composeGuardsOr = (guards) => {
-    if (guards.length === 0) {
-        throw new EmptyGuardArrayError("or");
-    }
-    if (guards.length === 1) {
-        // One guard passes through. asXStateGuard gives the reason for the boundary.
-        return asXStateGuard(guards[0]);
-    }
-    // Use the built-in or() of XState, for the type inference and the serialization.
-    return or(asXStateGuard(guards));
-};
-/**
- * Negates a guard, through the not() helper of XState
- *
- * The function inverts the result of a guard: the guard passes, and NOT then fails;
- * the guard fails, and NOT then passes. It uses the built-in `not()` helper of
- * XState, and the serialization is therefore correct.
- *
- * @typeParam TContext - The context type of the state machine
- * @typeParam TEvent - The event type
- *
- * @param guard - The guard predicate to negate, or its name
- * @returns The not() guard negation of XState
- *
- * @example
- * A NOT composition with a named guard
- * ```typescript
- * import { setup } from "xstate";
- * import { negateGuard } from "@xmachines/play-xstate";
- *
- * const machine = setup({
- *   guards: {
- *     isGuest: ({ context }) => !context.userId
- *   }
- * }).createMachine({
- *   on: {
- *     accessDashboard: {
- *       // Permit the transition when the user is NOT a guest, which means an authenticated user
- *       guard: negateGuard('isGuest'),
- *       target: 'dashboard'
- *     }
- *   }
- * });
- * ```
- *
- * @see {@link composeGuards} for the AND composition
- * @see {@link composeGuardsOr} for the OR composition
- * @deprecated Use the `and()`, `or()`, and `not()` combinators of XState directly. This helper
- * does not compose with a guard slot that `setup()` types, and the next major version removes it.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const negateGuard = (guard) => {
-    // XState 5.28.0: not() requires one SingleGuardArg shape, and not the Guard
-    // type of this package. See asXStateGuard.
-    return not(asXStateGuard(guard));
-};
-//# sourceMappingURL=compose.js.map

package/dist/guards/compose.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"compose.js","sourceRoot":"","sources":["../../src/guards/compose.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AAItC,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEpD;;;;;;;;;;;;;GAaG;AACH,MAAM,aAAa,GAAG,CAAI,KAAc,EAAK,EAAE,CAAC,KAAU,CAAC;AAmB3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,8DAA8D;AAC9D,MAAM,CAAC,MAAM,aAAa,GAAG,CAC5B,MAAoC,EACpB,EAAE;IAClB,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,oBAAoB,CAAC,KAAK,CAAC,CAAC;IACvC,CAAC;IAED,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,6EAA6E;QAC7E,OAAO,aAAa,CAAgB,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAChD,CAAC;IAED,kFAAkF;IAClF,OAAO,GAAG,CAAC,aAAa,CAA4B,MAAM,CAAC,CAAC,CAAC;AAC9D,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,8DAA8D;AAC9D,MAAM,CAAC,MAAM,eAAe,GAAG,CAC9B,MAAoC,EACpB,EAAE;IAClB,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,oBAAoB,CAAC,IAAI,CAAC,CAAC;IACtC,CAAC;IAED,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,6EAA6E;QAC7E,OAAO,aAAa,CAAgB,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAChD,CAAC;IAED,iFAAiF;IACjF,OAAO,EAAE,CAAC,aAAa,CAA2B,MAAM,CAAC,CAAC,CAAC;AAC5D,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,8DAA8D;AAC9D,MAAM,CAAC,MAAM,WAAW,GAAG,CAC1B,KAAuC,EACvB,EAAE;IAClB,4EAA4E;IAC5E,2CAA2C;IAC3C,OAAO,GAAG,CAAC,aAAa,CAA4B,KAAK,CAAC,CAAC,CAAC;AAC7D,CAAC,CAAC"}

package/dist/guards/helpers.d.ts

@@ -1,62 +0,0 @@
-import type { Guard } from "./types.js";
-import type { PlayEvent } from "@xmachines/play";
-/**
- * Tells you if the context holds a value at the path, and that the value is truthy
- *
- * @example
- * ```typescript
- * const machine = setup({
- *   guards: {
- *     hasUserId: hasContext('userId'),
- *     hasEmail: hasContext('user.email')
- *   }
- * });
- * ```
- *
- * @param path - The path to the context property, with a dot between two segments
- * @returns The guard predicate. It tests the property for a truthy value
- * @deprecated This function is part of the guard utilities, and the next major version removes
- * them. Write a plain typed predicate instead.
- */
-export declare const hasContext: <TContext = Record<string, unknown>>(path: string) => Guard<TContext, PlayEvent>;
-/**
- * Tells you if the type of the event is the expected type
- *
- * @example
- * ```typescript
- * const machine = setup({
- *   guards: {
- *     isSubmitEvent: eventMatches('submit'),
- *     isBackOrForward: composeGuardsOr([
- *       eventMatches('back'),
- *       eventMatches('forward')
- *     ])
- *   }
- * });
- * ```
- *
- * @param eventType - The expected event type
- * @returns The guard predicate. It tests the event type
- * @deprecated This function is part of the guard utilities, and the next major version removes
- * them. Write a plain typed predicate instead.
- */
-export declare const eventMatches: <TEvent extends PlayEvent = PlayEvent>(eventType: string) => Guard<unknown, TEvent>;
-/**
- * Tells you if a context field holds the expected value.
- *
- * - The function accepts an explicit field path, with a dot between two segments, for example `"user.role"`
- * - It compares a primitive with a strict equality, and an object with a deep structural equality
- * - The order of the keys has no effect on the comparison of an object: `{a:1,b:2}` equals `{b:2,a:1}`
- * - It supports a Date, a RegExp, an instance of a class, a nested object, and an array, through `dequal/lite`
- * - It does NOT match a substring: `"a"` does not match `"active"`
- *
- * For a match of an XState state node, use the built-in `in:` guard syntax instead.
- *
- * @param fieldPath - The path to the context property, with a dot between two segments, for example "status" or "user.role"
- * @param expectedValue - The value for the comparison: a string, an object, a Date, and so on
- * @returns The guard predicate. It tests the context field for the value
- * @deprecated This function is part of the guard utilities, and the next major version removes
- * them. Write a plain typed predicate instead.
- */
-export declare const contextFieldMatches: <TContext = Record<string, unknown>>(fieldPath: string, expectedValue: unknown) => Guard<TContext, PlayEvent>;
-//# sourceMappingURL=helpers.d.ts.map

package/dist/guards/helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/guards/helpers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU,GACrB,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,MAAM,KAAG,KAAK,CAAC,QAAQ,EAAE,SAAS,CAI5E,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,YAAY,GACvB,MAAM,SAAS,SAAS,GAAG,SAAS,EAAE,WAAW,MAAM,KAAG,KAAK,CAAC,OAAO,EAAE,MAAM,CAG/E,CAAC;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,mBAAmB,GAC9B,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,WAAW,MAAM,EACjB,eAAe,OAAO,KACpB,KAAK,CAAC,QAAQ,EAAE,SAAS,CAI3B,CAAC"}

package/dist/guards/helpers.js

@@ -1,85 +0,0 @@
-import { dequal } from "dequal/lite";
-/**
- * Tells you if the context holds a value at the path, and that the value is truthy
- *
- * @example
- * ```typescript
- * const machine = setup({
- *   guards: {
- *     hasUserId: hasContext('userId'),
- *     hasEmail: hasContext('user.email')
- *   }
- * });
- * ```
- *
- * @param path - The path to the context property, with a dot between two segments
- * @returns The guard predicate. It tests the property for a truthy value
- * @deprecated This function is part of the guard utilities, and the next major version removes
- * them. Write a plain typed predicate instead.
- */
-export const hasContext = (path) => ({ context }) => {
-    const value = getNestedValue(context, path);
-    return value !== undefined && value !== null && value !== "";
-};
-/**
- * Tells you if the type of the event is the expected type
- *
- * @example
- * ```typescript
- * const machine = setup({
- *   guards: {
- *     isSubmitEvent: eventMatches('submit'),
- *     isBackOrForward: composeGuardsOr([
- *       eventMatches('back'),
- *       eventMatches('forward')
- *     ])
- *   }
- * });
- * ```
- *
- * @param eventType - The expected event type
- * @returns The guard predicate. It tests the event type
- * @deprecated This function is part of the guard utilities, and the next major version removes
- * them. Write a plain typed predicate instead.
- */
-export const eventMatches = (eventType) => ({ event }) => {
-    return event.type === eventType;
-};
-/**
- * Tells you if a context field holds the expected value.
- *
- * - The function accepts an explicit field path, with a dot between two segments, for example `"user.role"`
- * - It compares a primitive with a strict equality, and an object with a deep structural equality
- * - The order of the keys has no effect on the comparison of an object: `{a:1,b:2}` equals `{b:2,a:1}`
- * - It supports a Date, a RegExp, an instance of a class, a nested object, and an array, through `dequal/lite`
- * - It does NOT match a substring: `"a"` does not match `"active"`
- *
- * For a match of an XState state node, use the built-in `in:` guard syntax instead.
- *
- * @param fieldPath - The path to the context property, with a dot between two segments, for example "status" or "user.role"
- * @param expectedValue - The value for the comparison: a string, an object, a Date, and so on
- * @returns The guard predicate. It tests the context field for the value
- * @deprecated This function is part of the guard utilities, and the next major version removes
- * them. Write a plain typed predicate instead.
- */
-export const contextFieldMatches = (fieldPath, expectedValue) => ({ context }) => {
-    const actual = getNestedValue(context, fieldPath);
-    return dequal(actual, expectedValue);
-};
-/**
- * Returns a nested value of an object, from a path with a dot between two segments
- *
- * @internal
- */
-const getNestedValue = (obj, path) => {
-    const keys = path.split(".");
-    let value = obj;
-    for (const key of keys) {
-        if (value === null || value === undefined || typeof value !== "object") {
-            return undefined;
-        }
-        value = value[key]; // nosemgrep: gitlab.eslint.detect-object-injection
-    }
-    return value;
-};
-//# sourceMappingURL=helpers.js.map

package/dist/guards/helpers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/guards/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAIrC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,UAAU,GACtB,CAAqC,IAAY,EAA8B,EAAE,CACjF,CAAC,EAAE,OAAO,EAAyB,EAAE,EAAE;IACtC,MAAM,KAAK,GAAG,cAAc,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAC5C,OAAO,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,EAAE,CAAC;AAC9D,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,YAAY,GACxB,CAAuC,SAAiB,EAA0B,EAAE,CACpF,CAAC,EAAE,KAAK,EAAqB,EAAE,EAAE;IAChC,OAAO,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC;AACjC,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAC/B,CACC,SAAiB,EACjB,aAAsB,EACO,EAAE,CAChC,CAAC,EAAE,OAAO,EAAyB,EAAE,EAAE;IACtC,MAAM,MAAM,GAAG,cAAc,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IAClD,OAAO,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AACtC,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,cAAc,GAAG,CAAC,GAAY,EAAE,IAAY,EAAW,EAAE;IAC9D,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC7B,IAAI,KAAK,GAAG,GAAG,CAAC;IAEhB,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACxB,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YACxE,OAAO,SAAS,CAAC;QAClB,CAAC;QACD,KAAK,GAAI,KAAiC,CAAC,GAAG,CAAC,CAAC,CAAC,mDAAmD;IACrG,CAAC;IAED,OAAO,KAAK,CAAC;AACd,CAAC,CAAC"}

package/dist/guards/index.d.ts

@@ -1,20 +0,0 @@
-/**
- * The guard composition utilities and the guard helpers of an XState machine
- *
- * The package gives you a composition where an array means AND. It also gives you
- * the helpers of the common guard patterns of the Play Architecture.
- *
- * @deprecated These guard helpers wrap the `and`, `or`, and `not` combinators of
- * XState, but they do not compose with a guard slot that `setup()` types. The
- * example of the package itself needs a cast for them. Use the combinators of XState
- * directly. The next major version removes this module. Each exported symbol carries
- * its own deprecation tag, because a consumer imports it through the root of the
- * package, and not through this barrel.
- *
- * @packageDocumentation
- */
-export { composeGuards, composeGuardsOr, negateGuard } from "./compose.js";
-export type { ComposedGuard } from "./compose.js";
-export { hasContext, eventMatches, contextFieldMatches } from "./helpers.js";
-export type { Guard, GuardArray } from "./types.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/guards/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/guards/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3E,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAC7E,YAAY,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}

package/dist/guards/index.js

@@ -1,18 +0,0 @@
-/**
- * The guard composition utilities and the guard helpers of an XState machine
- *
- * The package gives you a composition where an array means AND. It also gives you
- * the helpers of the common guard patterns of the Play Architecture.
- *
- * @deprecated These guard helpers wrap the `and`, `or`, and `not` combinators of
- * XState, but they do not compose with a guard slot that `setup()` types. The
- * example of the package itself needs a cast for them. Use the combinators of XState
- * directly. The next major version removes this module. Each exported symbol carries
- * its own deprecation tag, because a consumer imports it through the root of the
- * package, and not through this barrel.
- *
- * @packageDocumentation
- */
-export { composeGuards, composeGuardsOr, negateGuard } from "./compose.js";
-export { hasContext, eventMatches, contextFieldMatches } from "./helpers.js";
-//# sourceMappingURL=index.js.map

package/dist/guards/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/guards/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3E,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC"}