fix(deps): update xstate monorepo (major)

[renovate]

This PR contains the following updates:

Package	Change	Age	Adoption	Passing	Confidence
@xstate/react (source)	1.6.3 -> 4.1.3
xstate (source)	4.38.3 -> 5.18.2

---

Release Notes

statelyai/xstate (@​xstate/react)

v4.1.3

Compare Source

Patch Changes

• Updated dependencies [25963966c394fc904dc9b701a420b6e204ebe7f7]:
  • [email protected]

v4.1.2

Compare Source

Patch Changes

• #​5055 ad38c35c37 Thanks @​SandroMaglione! - Updated types of useActor, useMachine, and useActorRef to require input when defined inside types/input.

  Previously even when input was defined inside types, useActor, useMachine, and useActorRef would not make the input required:

  const machine = setup({
    types: {
      input: {} as { value: number }
    }
  }).createMachine({});
  
  function App() {
    // Event if `input` is not defined, `useMachine` works at compile time, but risks crashing at runtime
    const _ = useMachine(machine);
    return <></>;
  }

  With this change the above code will show a type error, since input is now required:

  const machine = setup({
    types: {
      input: {} as { value: number }
    }
  }).createMachine({});
  
  function App() {
    const _ = useMachine(machine, {
      input: { value: 1 } // Now input is required at compile time!
    });
    return <></>;
  }

  This avoids runtime errors when forgetting to pass input when defined inside types.

v4.1.1

Compare Source

Patch Changes

• #​4844 5aa6eb05c Thanks @​davidkpiano! - The useSelector(…) hook from @xstate/react is now compatible with stores from @xstate/store.

  import { createStore } from '@​xstate/store';
  import { useSelector } from '@​xstate/react';
  
  const store = createStore(
    {
      count: 0
    },
    {
      inc: {
        count: (context) => context.count + 1
      }
    }
  );
  
  function Counter() {
    // Note that this `useSelector` is from `@xstate/react`,
    // not `@xstate/store/react`
    const count = useSelector(store, (state) => state.context.count);
  
    return (
      <div>
        <button onClick={() => store.send({ type: 'inc' })}>{count}</button>
      </div>
    );
  }

v4.1.0

Compare Source

Minor Changes

• #​4231 c2402e7bc Thanks @​davidkpiano! - The actor passed to useSelector(actor, selector) is now allowed to be undefined for an actor that may not exist yet. For actors that may be undefined, the snapshot provided to the selector function can also be undefined:

  const count = useSelector(maybeActor, (snapshot) => {
    // `snapshot` may be undefined
    return snapshot?.context.count;
  });
  
  count; // number | undefined

v4.0.3

Compare Source

Patch Changes

• #​4695 52900a084 Thanks @​davidkpiano! - Options in createActorContext are now properly merged with provider options. Previously, provider options replaced the actor options.

  const { inspect } = createBrowserInspector();
  
  const SomeContext = createActorContext(someMachine, { inspect });
  
  // ...
  // Options are now merged:
  // { inspect: inspect, input: 10 }
  <SomeContext.Provider options={{ input: 10 }}>
    {/* ... */}
  </SomeContext.Provider>;

v4.0.2

Compare Source

Patch Changes

• #​4600 1f2ccb97c Thanks @​davidkpiano! - Typegen-based types for detecting missing implementations have been removed internally.

v4.0.1

Compare Source

Patch Changes

• #​4497 d7f220225 Thanks @​davidkpiano! - Fix an issue where after transitions do not work in React strict mode. Delayed events (including from after transitions) should now work as expected in all React modes.

v4.0.0

Compare Source

Major Changes

• #​3947 5fa3a0c74 Thanks @​davidkpiano! - Removed the ability to pass a factory function as argument to useMachine.

• #​4006 42df9a536 Thanks @​davidkpiano! - useActorRef is introduced, which returns an ActorRef from actor logic:

  const actorRef = useActorRef(machine, { ... });
  const anotherActorRef = useActorRef(fromPromise(...));

  ~~useMachine~~ is deprecated in favor of useActor, which works with machines and any other kind of logic

  -const [state, send] = useMachine(machine);
  +const [state, send] = useActor(machine);
  const [state, send] = useActor(fromTransition(...));

  ~~useSpawn~~ is removed in favor of useActorRef

  -const actorRef = useSpawn(machine);
  +const actorRef = useActorRef(machine);
  
  The previous use of `useActor(actorRef)` is now replaced with just using the `actorRef` directly, and with `useSelector`:
  
  ```diff
  -const [state, send] = useActor(actorRef);
  +const state = useSelector(actorRef, s => s);
  // actorRef.send(...)

• #​4050 fc88dc8e6 Thanks @​davidkpiano! - The options prop has been added (back) to the Context.Provider component returned from createActorContext:

  const SomeContext = createActorContext(someMachine);
  
  // ...
  
  <SomeContext.Provider options={{ input: 42 }}>
    {/* ... */}
  </SomeContext.Provider>;

• #​4006 42df9a536 Thanks @​davidkpiano! - useActor has been removed from the created actor context, you should be able to replace its usage with MyCtx.useSelector and MyCtx.useActorRef.

• #​4265 1153b3f9a Thanks @​davidkpiano! - FSM-related functions have been removed.

• #​3947 5fa3a0c74 Thanks @​davidkpiano! - Implementations for machines on useMachine hooks should go directly on the machine via machine.provide(...), and are no longer allowed to be passed in as options.

  -const [state, send] = useMachine(machine, {
  -  actions: {
  -    // ...
  -  }
  -});
  +const [state, send] = useMachine(machine.provide({
  +  actions: {
  +    // ...
  +  }
  +}));

• #​3148 7a68cbb61 Thanks @​davidkpiano! - Removed getSnapshot parameter from hooks. It is expected that the received actorRef has to have a getSnapshot method on it that can be used internally.

Minor Changes

• #​3727 5fb3c683d Thanks @​Andarist! - exports field has been added to the package.json manifest. It limits what files can be imported from a package - it's no longer possible to import from files that are not considered to be a part of the public API.
• #​4240 409552cf8 Thanks @​davidkpiano! - The useMachine function is an alias of useActor.
• #​4436 340aee643 Thanks @​Andarist! - Fast refresh now works as expected for most use-cases.
• #​4050 fc88dc8e6 Thanks @​davidkpiano! - The observerOrListener argument has been removed from the 3rd argument of createActorContext(logic, options).

v3.2.2

Compare Source

Patch Changes

• #​3919 6665f0a32 Thanks @​c-w! - Updated the allowed range for the use-isomorphic-layout-effect dependency.

v3.2.1

Compare Source

Patch Changes

• #​3829 c110c429d Thanks @​Andarist! - Fixed compatibility of the generated TS types for createActorContext with pre-4.7.

v3.2.0

Compare Source

Minor Changes

• #​3814 494203b3d Thanks @​Andarist! - The Provider from createActorContext(...) now accepts the options={{...}} prop that takes the same object as the second argument to the useMachine(machine, options) hook.

  These options are no longer passed as the second argument to the createActorContext(machine) function:

  -const SomeContext = createActorContext(someMachine,
  -  { actions: { ... } });
  +const SomeContext = createActorContext(someMachine);
  
  // ...
  
  -<SomeContext.Provider>
  +<SomeContext.Provider options={{ actions: { ... } }}>
  
  // ...

v3.1.2

Compare Source

Patch Changes

• #​3804 b53856d28 Thanks @​farskid! - Interpreter options can now be specified in the second argument of createActorContext(machine, options).

v3.1.1

Compare Source

Patch Changes

• #​3799 51d254692 Thanks @​Andarist! - Fixed an issue that caused the internally used useSyncExternalStore to warn about the computed snapshot not being cached when a not-started machine servive was passed to useActor.

v3.1.0

Compare Source

Minor Changes

• #​3778 f12248b23 Thanks @​davidkpiano! - The createActorContext(...) helper has been introduced to make global actors easier to use with React. It outputs a React Context object with the following properties:

  • .Provider - The React Context provider
  • .useActor(...) - A hook that can be used to get the current state and send events to the actor
  • .useSelector(...) - A hook that can be used to select some derived state from the actor's state
  • .useActorRef() - A hook that can be used to get a reference to the actor that can be passed to other components

  Usage:

  import { createActorContext } from '@​xstate/react';
  import { someMachine } from './someMachine';
  
  // Create a React Context object that will interpret the machine
  const SomeContext = createActorContext(someMachine);
  
  function SomeComponent() {
    // Get the current state and `send` function
    const [state, send] = SomeContext.useActor();
  
    // Or select some derived state
    const someValue = SomeContext.useSelector((state) => state.context.someValue);
  
    // Or get a reference to the actor
    const actorRef = SomeContext.useActorRef();
  
    return (/* ... */);
  }
  
  function App() {
    return (
      <SomeContext.Provider>
        <SomeComponent />
      </SomeContext.Provider>
    );
  }

v3.0.2

Compare Source

Patch Changes

• #​3752 4190c3fd6 Thanks @​davidkpiano! - Computing the initial state is now consistent with useMachine and useActor, avoiding stale initial state problems with nested machines

v3.0.1

Compare Source

Patch Changes

• #​3456 131d429ab Thanks @​davidkpiano! - Add shallowEqual helper comparator function.

• #​3500 0dfc6d92f Thanks @​Andarist! - Fixed an issue with useSelector always computing fresh snapshots internally for uninitialized services. This avoids the internal useSyncExternalStore from warning about the snapshot value not being cached properly.

v3.0.0

Compare Source

Major Changes

• #​2939 360e85462 Thanks @​Andarist! - This package now accepts React 18 as a peer dep and the implementation has been rewritten to use use-sync-external-store package. This doesn't break compatibility with older versions of React since we are using the shim to keep compatibility with those older versions.

• #​2939 360e85462 Thanks @​Andarist! - asEffect and asLayoutEffect action creators were removed. They were not fitting the React model that well and could lead to issues as their existence suggested that they are easy to use.

  To execute actions at those exact times you can always either just call your stuff directly from those effects or send events to the machine from those effects and execute explicit actions in response to said events.

• #​2939 360e85462 Thanks @​Andarist! - The signatures of useMachine and useService integrating with @xstate/fsm were changed. They now only accept a single generic each (TMachine and TService respectively). This has been done to match their signatures with the related hooks that integrate with xstate itself.

Patch Changes

• #​2939 360e85462 Thanks @​Andarist! - In v2 we have changed signatures of useMachine and useInterpret. Instead of accepting a list of generics they now only support a single generic: TMachine. This change, erroneously, was only introduced to types targeting [email protected] but the types targeting previous TS releases were still using the older signatures. This has now been fixed and users of older TS versions should now be able to leverage typegen with @xstate/react.

• #​2939 360e85462 Thanks @​Andarist! - useMachine for xstate now correctly rerenders with the initial state when the internal service is being restarted. This might happen during Fast Refresh and now you shouldn't be able to observe this stale state that didn't match the actual state of the service.

• #​2939 360e85462 Thanks @​Andarist! - useMachine for @xstate/fsm now starts the service in an effect. This avoids side-effects in render and improves the compatibility with StrictMode.

• #​2939 360e85462 Thanks @​Andarist! - Implementations given to useMachine targeting @xstate/fsm are now updated in a layout effect. This avoid some stale closure problems for actions that are executed in response to events sent from layout effects.

• Updated dependencies [360e85462, 360e85462]:

  • @​xstate/fsm@​2.0.0

v2.0.1

Compare Source

Patch Changes

• #​3089 862697e29 Thanks @​Andarist! - Fixed compatibility with Skypack by exporting some shared utilities from root entry of XState and consuming them directly in other packages (this avoids accessing those things using deep imports and thus it avoids creating those compatibility problems).

v2.0.0

Compare Source

Major Changes

• #​5000 eeadb7121 Thanks @​TkDodo! - - Replace use-sync-external-store/shim with useSyncExternalStore from React.
  • Do not memoize getSnapshot in useSyncExternalStore.
  • Implement getServerSnapshot in useSyncExternalStore.
  • Expect store to always be defined in useSelector
  • Update React types to v18 and testing library to v16.

---

Configuration

📅 Schedule: Branch creation - "after 10pm every weekday,before 5am every weekday" in timezone Europe/London, Automerge - At any time (no schedule defined).

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR is behind base branch, or you tick the rebase/retry checkbox.

👻 Immortal: This PR will be recreated if closed unmerged. Get config help if that's undesired.

---

• If you want to rebase/retry this PR, check this box

---

This PR was generated by Mend Renovate. View the repository job log.