Implementing Fast Refresh in a Custom React Environment

This challenge asks you to implement the core logic behind React's Fast Refresh feature. Fast Refresh is crucial for a modern React development experience, allowing you to see the results of your code changes almost instantly without losing component state. You'll be building a simplified, in-memory version of this logic.

Problem Description

You need to simulate the behavior of React's Fast Refresh. When a React component's code is edited and re-executed, Fast Refresh tries to update the component in place, preserving its current state. If the edited component is a function component and is still a function component, its state is preserved. If it becomes a class component or vice-versa, or if an error occurs, the component is re-mounted.

Your task is to create a fastRefresh function that takes the previous component instance and the newly imported module containing the updated component. This function should intelligently decide whether to update the existing component instance or re-mount it.

Key Requirements:

1. State Preservation: If the updated component is a function component and the previous instance was also a function component, its internal state (simulated in this challenge) should be preserved.
2. Type Change Detection: Detect if the component has changed from a function component to a class component, or vice-versa. In such cases, re-mounting is necessary.
3. Error Handling: If the new module import results in an error, the component should be re-mounted.
4. Module Re-execution: Assume that importing the new module effectively re-executes the component's code.

Expected Behavior:

• If an existing function component is updated with a new function component that has the same signature (conceptually), its state should be preserved.
• If a function component is updated to a class component, or vice-versa, the component should be re-mounted.
• If the new module code throws an error during import, the component should be re-mounted.
• If the new component is an entirely new component (e.g., the first render), it should be mounted.

Examples

Example 1: Function Component Update (State Preservation)

Input:
- `previousInstance`: An object representing a function component instance with `state = { count: 1 }`.
- `newModule`: An object `{ Component: (props) => { ... } }` where `Component` is a function that uses `useState` internally to manage a `count` state.
- `isFunctionComponent`: `true` (for both previous and new)

Output:
- The `previousInstance` should be updated with the new component logic.
- The `state` of the instance should remain `{ count: 1 }`.
- The new component function should be executed with the preserved state.

Example 2: Type Change (Function to Class)

Input:
- `previousInstance`: An object representing a function component instance.
- `newModule`: An object `{ Component: class MyComponent { ... } }` where `Component` is a class.
- `isFunctionComponent`: `false` (for `previousInstance`'s type), `true` (for `newModule`'s type)

Output:
- A new component instance should be created.
- The old `previousInstance` is discarded.

Example 3: Error During Import

Input:
- `previousInstance`: An object representing a component instance.
- `newModule`: `null` (simulating an import error where `newModule` is not successfully loaded)
- `error`: An `Error` object.

Output:
- A new component instance should be created.
- The old `previousInstance` is discarded.

Constraints

• This challenge operates in a simulated, in-memory environment. You do not need to interact with actual DOM or React hooks like useState, useEffect directly. Instead, you'll be manipulating placeholder objects that represent component instances and their state.
• The newModule will be an object. If the import is successful, it will have a Component property that is either a function or a class. If there's an error, newModule might be null or undefined, and an error object will be provided.
• Assume isFunctionComponent is a boolean that correctly identifies the type of the new component in newModule.
• Your fastRefresh function will return the new or updated component instance.

Notes

• Think about how React identifies if a component is a function or a class.
• Consider the implications of a component's signature changing. For simplicity, assume that if the type (function/class) remains the same, and there are no explicit "errors" from the import, state preservation is attempted.
• The core idea is to avoid unnecessary re-renders and state loss when only minor code adjustments are made to a component.
• For this simulation, you can represent component state as a simple object. When preserving state, you are essentially passing the old state object to the new component instance's rendering logic.