@flux-control/effect-modbus-rs
    Preparing search index...

    Class WasmWsTransportService

    Scoped Effect service wrapping modbus-rs's browser WasmWsTransport for Modbus TCP over a WebSocket gateway (browsers can't open raw TCP sockets).

    The transport connection is opened lazily on the first call to withClient(unitId) and automatically closed when the consuming scope finalizes.

    Clients are created per unitId via WasmWsTransport.createClient and cached, so repeated requests for the same unit ID reuse the same client.

    • WasmWsTransport — Upstream modbus-rs browser WebSocket transport.
    • WasmWsTransportOptions — Configuration for the WebSocket gateway connection.
    • createTransportScoped — Generic lifecycle logic from shared-transport.

    Hierarchy

    • Shape<"WasmWsTransportService", TransportServiceApi, this>
      • WasmWsTransportService
    Index
    constructor
    makeScoped
    make makeMockTransport

    • Parameters

      • _: never

      Returns WasmWsTransportService

    makeScoped: (
        ...args: [options: WasmWsTransportOptions & TransportResilienceOptions],
    ) => Effect<
        {
            batchingClient: (
                unitId: number,
            ) => Effect<BatchingModbusClient, ModbusError>;
            clearRequestTimeout: (
                ...args: [],
            ) => Effect<undefined, ModbusNotConnectedError, never>;
            close: (...args: [scope: Closeable]) => Effect<void, ModbusError, never>;
            connectionState: SubscriptionRef<
                {}
                | {}
                | { attempt: number }
                | { cause: ModbusError },
            >;
            hasPendingRequests: () => boolean;
            reconnect: (...args: []) => Effect<undefined, ModbusError, never>;
            setRequestTimeout: (
                ...args: [timeoutMs: number],
            ) => Effect<undefined, ModbusNotConnectedError, never>;
            withBatchingClient: (
                unitId: number,
                options?: BatchingClientOptions & { retry?: ModbusRetryPolicy },
            ) => Effect<
                BatchingModbusClient,
                ModbusUnitAlreadyDeclaredError
                | ModbusError,
            >;
            withClient: (
                ...args: [
                    unitId: number,
                    clientOptions?: { retry?: ModbusRetryPolicy },
                ],
            ) => Effect<EffectModbusClient, ModbusError, never>;
            get touchedUnits(): Set<number>;
        },
        never,
        Scope,
    > = ...

    Builds the scoped transport service effect. The transport opens on first use and its connection closes when the consuming scope ends.

    Type Declaration

      • (
            ...args: [options: WasmWsTransportOptions & TransportResilienceOptions],
        ): Effect<
            {
                batchingClient: (
                    unitId: number,
                ) => Effect<BatchingModbusClient, ModbusError>;
                clearRequestTimeout: (
                    ...args: [],
                ) => Effect<undefined, ModbusNotConnectedError, never>;
                close: (...args: [scope: Closeable]) => Effect<void, ModbusError, never>;
                connectionState: SubscriptionRef<
                    {}
                    | {}
                    | { attempt: number }
                    | { cause: ModbusError },
                >;
                hasPendingRequests: () => boolean;
                reconnect: (...args: []) => Effect<undefined, ModbusError, never>;
                setRequestTimeout: (
                    ...args: [timeoutMs: number],
                ) => Effect<undefined, ModbusNotConnectedError, never>;
                withBatchingClient: (
                    unitId: number,
                    options?: BatchingClientOptions & { retry?: ModbusRetryPolicy },
                ) => Effect<
                    BatchingModbusClient,
                    ModbusUnitAlreadyDeclaredError
                    | ModbusError,
                >;
                withClient: (
                    ...args: [
                        unitId: number,
                        clientOptions?: { retry?: ModbusRetryPolicy },
                    ],
                ) => Effect<EffectModbusClient, ModbusError, never>;
                get touchedUnits(): Set<number>;
            },
            never,
            Scope,
        >

      • Parameters

        Returns Effect<
            {
                batchingClient: (
                    unitId: number,
                ) => Effect<BatchingModbusClient, ModbusError>;
                clearRequestTimeout: (
                    ...args: [],
                ) => Effect<undefined, ModbusNotConnectedError, never>;
                close: (...args: [scope: Closeable]) => Effect<void, ModbusError, never>;
                connectionState: SubscriptionRef<
                    {}
                    | {}
                    | { attempt: number }
                    | { cause: ModbusError },
                >;
                hasPendingRequests: () => boolean;
                reconnect: (...args: []) => Effect<undefined, ModbusError, never>;
                setRequestTimeout: (
                    ...args: [timeoutMs: number],
                ) => Effect<undefined, ModbusNotConnectedError, never>;
                withBatchingClient: (
                    unitId: number,
                    options?: BatchingClientOptions & { retry?: ModbusRetryPolicy },
                ) => Effect<
                    BatchingModbusClient,
                    ModbusUnitAlreadyDeclaredError
                    | ModbusError,
                >;
                withClient: (
                    ...args: [
                        unitId: number,
                        clientOptions?: { retry?: ModbusRetryPolicy },
                    ],
                ) => Effect<EffectModbusClient, ModbusError, never>;
                get touchedUnits(): Set<number>;
            },
            never,
            Scope,
        >

        An effect that provides the service for the lifetime of its scope.

    • Creates a Layer providing an in-memory mock WasmWsTransportService for testing or development.

      Accepts an array of SlaveDeviceDefinitions describing the simulated Modbus slaves and their register/coil maps.

      Parameters

      • devices: readonly {
            coils: readonly { address: number; default: boolean }[];
            discreteInputs: readonly { address: number; default: boolean }[];
            holdingRegisters: readonly { address: number; default: number }[];
            inputRegisters: readonly { address: number; default: number }[];
            unitId: number;
        }[]

        Slave device definitions for the mock.

      Returns (
          options: WasmWsTransportOptions & TransportResilienceOptions & MockFaultOptions,
      ) => Layer<WasmWsTransportService, never, never>

      A function that takes WasmWsTransportOptions and returns a scoped Layer providing the mock service. The mock uses device definitions and fault hooks instead of network I/O.

      makeMockTransport — The underlying mock factory.

    Settings
    Member Visibility

    On This Page
    Constructors
    Properties
    Methods