@dittolive/ditto 4.7.4 → 4.7.5-rc.2

package/react-native/src/sources/sync.ts

@@ -1,561 +0,0 @@
-//
-// Copyright © 2021 DittoLive Incorporated. All rights reserved.
-//
-
-import * as FFI from './ffi'
-import * as Environment from './@environment'
-
-import { desugarJSObject } from './augment'
-import { Bridge } from './bridge'
-import { CBOR } from './cbor'
-import { defaultDittoCloudURL } from './internal'
-import { SyncSubscription } from './sync-subscription'
-import { TransportConfig } from './transport-config'
-import { DittoError, mapFFIErrors } from './error'
-
-import type { Ditto } from './ditto'
-import type { Identity } from './identity'
-import type { DQLQueryArguments } from './essentials'
-
-/** @internal */
-export type SyncParameters = {
-  readonly isSyncActive: boolean
-  readonly isX509Valid: boolean
-  readonly isWebValid: boolean
-  readonly ditto: Ditto
-  readonly identity: Identity
-  readonly transportConfig: TransportConfig
-}
-
-/** @internal */
-export type SyncState = {
-  // NOTE: we can get away with just an effective transport config for now,
-  // but this is meant to carry more state if need be. Whenever possible,
-  // prefer putting logic into the `stateFrom()` function together with some
-  // flags here and keep the `updateXXX()` to just diffing and updating the
-  // low-level transports machinery.
-  readonly underlyingSyncParameters: SyncParameters
-  readonly effectiveTransportConfig: TransportConfig
-}
-
-/**
- * Provides access to sync related functionality of Ditto.
- *
- * Access this object via {@link Ditto.sync | Ditto.sync} on any Ditto instance.
- */
-export class Sync {
-  /**
-   * The {@link Ditto} instance managed by this sync object.
-   */
-  readonly ditto: Ditto
-
-  /**
-   * All currently active sync subscriptions.
-   *
-   * **Note:** Manage sync subscriptions using
-   * {@link registerSubscription | registerSubscription()} to register a new
-   * sync subscription and
-   * {@link SyncSubscription.cancel | SyncSubscription.cancel()} to remove an
-   * existing sync subscription.
-   */
-  readonly subscriptions: Readonly<Array<SyncSubscription>> = Object.freeze([])
-
-  /**
-   * Installs and returns a sync subscription for a query, configuring Ditto to
-   * receive updates from other peers for documents matching that query. The
-   * passed in query must be a `SELECT` query, otherwise an error is thrown.
-   *
-   * @param query a string containing a valid query expressed in DQL.
-   * @param queryArguments an object containing the arguments for the query.
-   * Example: `{mileage: 123}` for a query with `:mileage` placeholder.
-   * @returns An active `SyncSubscription` for the passed in query and
-   * arguments. It will remain active until it is
-   * {@link SyncSubscription.cancel | cancelled} or the {@link Ditto} instance
-   * managing the sync subscription has been closed.
-   * @throws {@link DittoError} `query/invalid`: if `query` argument is not a
-   * string or not valid DQL.
-   * @throws {@link DittoError} `query/arguments-invalid`: if `queryArguments`
-   * argument is invalid (e.g. contains unsupported types).
-   * @throws {@link DittoError} `query/unsupported`: if the query is not a
-   * `SELECT` query.
-   * @throws {@link DittoError} may throw other errors.
-   */
-  registerSubscription(query: string, queryArguments?: DQLQueryArguments): SyncSubscription {
-    if (typeof query !== 'string') {
-      throw new DittoError('query/invalid', `Expected parameter 'query' to be of type 'string', found: ${typeof query}`)
-    }
-
-    let queryArgumentsCBOR: Uint8Array | null = null
-    if (queryArguments != null) {
-      try {
-        const queryArgumentsJSON = desugarJSObject(queryArguments)
-        queryArgumentsCBOR = CBOR.encode(queryArgumentsJSON)
-      } catch (error: any) {
-        throw new DittoError('query/arguments-invalid', `Unable to encode query arguments: ${error.message}`)
-      }
-    }
-
-    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
-    this.ditto.deferClose(() => {
-      mapFFIErrors(() => FFI.tryAddSyncSubscription(dittoHandle.deref(), query, queryArgumentsCBOR))
-    })
-
-    const subscription = new SyncSubscription(this.ditto, query, queryArguments || null, queryArgumentsCBOR)
-
-    // @ts-expect-error modifying readonly property
-    this.subscriptions = Object.freeze([...this.subscriptions, subscription])
-
-    return subscription
-  }
-
-  // ---------------------------------------------------------- Internal ------
-
-  /** @internal */
-  get parameters(): SyncParameters {
-    return this.state.underlyingSyncParameters
-  }
-
-  /** @internal */
-  constructor(ditto: Ditto) {
-    const identity = ditto.identity
-    const transportConfig = new TransportConfig()
-    const parameters = { identity, transportConfig, ditto, isWebValid: false, isX509Valid: false, isSyncActive: false }
-
-    this.ditto = ditto
-    this.state = stateFrom(parameters)
-
-    FFI.transportsInit()
-  }
-
-  /**
-   * Removes the passed in `syncSubscription`, configuring Ditto to not receive
-   * updates for documents matching the corresponding query anymore. No-op if
-   * the passed in `syncSubscription` has already been removed.
-   *
-   * This must only be called by the sync subscription itself.
-   *
-   * @param syncSubscription the sync subscription to remove
-   * @returns `true` if the passed in sync subscription could be found and has
-   * been removed, otherwise returns `false`.
-   * @throws {@link DittoError} `internal`: if the replication subscription does not
-   * belong to this store
-   * @throws {@link DittoError} `internal`: if the replication subscription has not
-   * been cancelled yet
-   * @internal
-   */
-  unregisterSubscription(syncSubscription: SyncSubscription): boolean {
-    if (syncSubscription.ditto !== this.ditto) {
-      throw new DittoError('internal', `Can't remove replication subscription that does not belong to this store`)
-    }
-
-    if (!syncSubscription.isCancelled) {
-      throw new DittoError('internal', "Internal inconsistency, can't remove replication subscription that has not been cancelled")
-    }
-
-    const indexToDelete = this.subscriptions.findIndex((s) => s === syncSubscription)
-    if (indexToDelete === -1) {
-      return false
-    }
-
-    const newSyncSubscriptions = [...this.subscriptions]
-    newSyncSubscriptions.splice(indexToDelete, 1)
-    // @ts-expect-error modifying readonly property
-    this.subscriptions = Object.freeze(newSyncSubscriptions)
-
-    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
-    this.ditto.deferClose(() => {
-      // prettier-ignore
-      mapFFIErrors(
-        () => FFI.tryRemoveSyncSubscription(dittoHandle.deref(), syncSubscription.queryString, syncSubscription.queryArgumentsCBOR)
-      )
-    })
-    return true
-  }
-
-  /** @internal */
-  update(parameters: SyncParameters) {
-    // NOTE: updating is a two-step process. Given all parameters, we
-    // first compute the final "state" we want the transports stuff to
-    // be in via the `stateFrom()` function. We then take that "desired" state
-    // and feed it into the various update methods, which essentially perform
-    // a diff on the state before and after, and update the low-level transports
-    // machinery accordingly.
-
-    const stateOld = this.state
-    const stateNew = stateFrom(parameters)
-
-    this.updatePeerToPeerBluetoothLE(stateOld, stateNew)
-    this.updatePeerToPeerAWDL(stateOld, stateNew)
-    this.updatePeerToPeerLAN(stateOld, stateNew)
-    this.updateListenTCP(stateOld, stateNew)
-    this.updateListenHTTP(stateOld, stateNew)
-    this.updateConnectTCPServers(stateOld, stateNew)
-    this.updateConnectWebsocketURLs(stateOld, stateNew)
-    this.updateGlobal(stateOld, stateNew)
-    this.updateConnectRetryInterval(stateOld, stateNew)
-
-    this.state = stateNew
-  }
-
-  /** @internal */
-  close() {
-    if (this.parameters.isSyncActive) {
-      throw new Error(`Internal inconsistency, can't close sync object while sync is active, please 'stopSync()' first.`)
-    }
-
-    for (const subscription of this.subscriptions) {
-      subscription.cancel()
-    }
-
-    // Nothing to do, when sync is stopped, this object should be
-    // already be cleaned up properly.
-  }
-
-  // ------------------------------------------------------------ Private ------
-
-  private state: SyncState
-
-  private bluetoothLETransportPointer: FFI.Pointer<'DittoTransportsBLE_t'> | null = null
-  private awdlTransportPointer: FFI.Pointer<'DittoTransportsAWDL_t'> | null = null
-  private lanTransportPointer: FFI.Pointer<'DittoTransportsLAN_t'> | null = null
-  private mdnsClientTransportPointer: FFI.Pointer<'DittoTransportsMdnsClient_t'> | null = null
-  private mdnsServerAdvertiserPointer: FFI.Pointer<'DittoTransportsMdnsServer_t'> | null = null
-
-  private updatePeerToPeerBluetoothLE(stateOld: SyncState, stateNew: SyncState) {
-    // Updating BLE transport is a no-op outside of Node.js & React Native.
-    if (!Environment.isNodeBuild && !Environment.isReactNativeBuild) return
-
-    const ditto = this.ditto
-    const dittoHandle = Bridge.ditto.handleFor(ditto)
-    ditto.deferClose(() => {
-      const bluetoothLEOld = stateOld.effectiveTransportConfig.peerToPeer.bluetoothLE
-      const bluetoothLENew = stateNew.effectiveTransportConfig.peerToPeer.bluetoothLE
-
-      const shouldStart = !bluetoothLEOld.isEnabled && bluetoothLENew.isEnabled
-      const shouldStop = bluetoothLEOld.isEnabled && !bluetoothLENew.isEnabled
-
-      if (shouldStart && this.bluetoothLETransportPointer) throw new Error(`Internal inconsistency, when starting BLE transport, no BLE transport pointer should exist.`)
-      if (shouldStop && !this.bluetoothLETransportPointer) throw new Error(`Internal inconsistency, when stopping BLE transport, a BLE transport pointer should exist.`)
-
-      if (process.platform === 'linux' || process.platform === 'win32') {
-        if (shouldStart) {
-          const clientTransport = FFI.dittoAddInternalBLEClientTransport(dittoHandle.deref())
-          const serverTransport = FFI.dittoAddInternalBLEServerTransport(dittoHandle.deref())
-          const blePlatform = { clientTransport, serverTransport } as any
-          this.bluetoothLETransportPointer = blePlatform
-        }
-
-        if (shouldStop) {
-          const blePlatform = this.bluetoothLETransportPointer as any
-          const { clientTransport, serverTransport } = blePlatform
-          FFI.bleServerFreeHandle(serverTransport)
-          FFI.bleClientFreeHandle(clientTransport)
-          this.bluetoothLETransportPointer = null
-        }
-
-        return
-      }
-
-      if (shouldStart) {
-        this.bluetoothLETransportPointer = FFI.transportsBLECreate(dittoHandle.deref()) as FFI.Pointer<FFI.TransportBluetooth> | null
-      }
-
-      if (shouldStop) {
-        // null check is performed above
-        FFI.transportsBLEDestroy(this.bluetoothLETransportPointer as FFI.Pointer<FFI.TransportBluetooth>)
-        this.bluetoothLETransportPointer = null
-      }
-    })
-  }
-
-  private updatePeerToPeerAWDL(stateOld: SyncState, stateNew: SyncState) {
-    // Updating AWDL transport is a no-op outside of Node.js & React Native.
-    if (!Environment.isNodeBuild && !Environment.isReactNativeBuild) return
-
-    const ditto = this.ditto
-    const dittoHandle = Bridge.ditto.handleFor(ditto)
-    ditto.deferClose(() => {
-      const awdlOld = stateOld.effectiveTransportConfig.peerToPeer.awdl
-      const awdlNew = stateNew.effectiveTransportConfig.peerToPeer.awdl
-
-      const shouldStart = !awdlOld.isEnabled && awdlNew.isEnabled
-      const shouldStop = awdlOld.isEnabled && !awdlNew.isEnabled
-
-      if (shouldStart && this.awdlTransportPointer) throw new Error(`Internal inconsistency, when starting AWDL transport, no AWDL transport pointer should exist.`)
-      if (shouldStop && !this.awdlTransportPointer) throw new Error(`Internal inconsistency, when stopping AWDL transport, an AWDL transport pointer should exist.`)
-
-      if (shouldStart) {
-        this.awdlTransportPointer = FFI.transportsAWDLCreate(dittoHandle.deref()) as FFI.Pointer<FFI.TransportAWDL> | null
-      }
-
-      if (shouldStop) {
-        // null check is performed above
-        FFI.transportsAWDLDestroy(this.awdlTransportPointer as FFI.Pointer<FFI.TransportAWDL>)
-        this.awdlTransportPointer = null
-      }
-    })
-  }
-
-  private updatePeerToPeerLAN(stateOld: SyncState, stateNew: SyncState) {
-    // Updating LAN transport currently only works with Node.js & React Native.
-    if (!Environment.isNodeBuild && !Environment.isReactNativeBuild) return
-
-    const ditto = this.ditto
-    const dittoHandle = Bridge.ditto.handleFor(ditto)
-    ditto.deferClose(() => {
-      const lanOld = stateOld.effectiveTransportConfig.peerToPeer.lan
-      const lanNew = stateNew.effectiveTransportConfig.peerToPeer.lan
-
-
-      if (process.platform === 'win32' || process.platform === 'linux') {
-        if (lanOld.isEnabled) {
-          if (lanOld.isMdnsEnabled) {
-            if (this.mdnsClientTransportPointer == null) throw new Error(`Internal inconsistency, when stopping LAN transport, a LAN transport pointer should exist.`)
-            FFI.mdnsClientFreeHandle(this.mdnsClientTransportPointer)
-            this.mdnsClientTransportPointer = null
-
-            if (this.mdnsServerAdvertiserPointer == null) throw new Error(`Internal inconsistency, when stopping LAN transport, a LAN transport pointer should exist.`)
-            FFI.mdnsServerFreeHandle(this.mdnsServerAdvertiserPointer)
-            this.mdnsServerAdvertiserPointer = null
-          }
-
-          if (lanOld.isMulticastEnabled) {
-            FFI.dittoRemoveMulticastTransport(dittoHandle.deref())
-          }
-        }
-
-        if (lanNew.isEnabled) {
-          if (lanNew.isMdnsEnabled) {
-            this.mdnsClientTransportPointer = FFI.dittoAddInternalMdnsTransport(dittoHandle.deref())
-            this.mdnsServerAdvertiserPointer = FFI.dittoAddInternalMdnsAdvertiser(dittoHandle.deref())
-          }
-
-          if (lanNew.isMulticastEnabled) {
-            FFI.dittoAddMulticastTransport(dittoHandle.deref())
-          }
-        }
-
-        return
-      }
-
-      // IDEA: move the logic for this dance into stateFrom() signal
-      // via some additional state signaling the actions here.
-
-      if (lanOld.isEnabled) {
-        if (lanOld.isMdnsEnabled) {
-          if (this.lanTransportPointer == null) throw new Error(`Internal inconsistency, when stopping LAN transport, a LAN transport pointer should exist.`)
-          FFI.transportsLANDestroy(this.lanTransportPointer as FFI.Pointer<FFI.TransportLAN>)
-          this.lanTransportPointer = null
-        }
-
-        if (lanOld.isMulticastEnabled) {
-          FFI.dittoRemoveMulticastTransport(dittoHandle.deref())
-        }
-      }
-
-      if (lanNew.isEnabled) {
-        if (lanNew.isMdnsEnabled) {
-          if (this.lanTransportPointer != null) throw new Error(`Internal inconsistency, when starting LAN transport, no LAN transport pointer should exist.`)
-          this.lanTransportPointer = FFI.transportsLANCreate(dittoHandle.deref()) as FFI.Pointer<FFI.TransportLAN>
-        }
-
-        if (lanNew.isMulticastEnabled) {
-          FFI.dittoAddMulticastTransport(dittoHandle.deref())
-        }
-      }
-    })
-  }
-
-  private updateListenTCP(stateOld: SyncState, stateNew: SyncState) {
-    const ditto = this.ditto
-    const dittoHandle = Bridge.ditto.handleFor(ditto)
-    ditto.deferClose(() => {
-      const tcpOld = stateOld.effectiveTransportConfig.listen.tcp
-      const tcpNew = stateNew.effectiveTransportConfig.listen.tcp
-
-      if (TransportConfig.areListenTCPsEqual(tcpNew, tcpOld)) return
-
-      if (tcpOld.isEnabled) FFI.dittoStopTCPServer(dittoHandle.deref())
-      if (tcpNew.isEnabled) FFI.dittoStartTCPServer(dittoHandle.deref(), `${tcpNew.interfaceIP}:${tcpNew.port}`)
-    })
-  }
-
-  private updateListenHTTP(stateOld: SyncState, stateNew: SyncState) {
-    const ditto = this.ditto
-    const dittoHandle = Bridge.ditto.handleFor(ditto)
-    ditto.deferClose(() => {
-      const httpOld = stateOld.effectiveTransportConfig.listen.http
-      const httpNew = stateNew.effectiveTransportConfig.listen.http
-
-      if (TransportConfig.areListenHTTPsEqual(httpOld, httpNew)) return
-      if (httpOld.isEnabled) FFI.dittoStopHTTPServer(dittoHandle.deref())
-
-      /* eslint-disable */
-      if (httpNew.isEnabled) {
-        FFI.dittoStartHTTPServer(dittoHandle.deref(), `${httpNew.interfaceIP}:${httpNew.port}`, httpNew.staticContentPath || null, httpNew.websocketSync ? 'Enabled' : 'Disabled', httpNew.tlsCertificatePath || null, httpNew.tlsKeyPath || null)
-      }
-      /* eslint-enable */
-    })
-  }
-
-  private updateConnectTCPServers(stateOld: SyncState, stateNew: SyncState) {
-    const ditto = this.ditto
-    const dittoHandle = Bridge.ditto.handleFor(ditto)
-    ditto.deferClose(() => {
-      const tcpServers = stateNew.effectiveTransportConfig.connect.tcpServers
-      FFI.dittoSetStaticTCPClients(dittoHandle.deref(), tcpServers)
-    })
-  }
-
-  private updateConnectWebsocketURLs(stateOld: SyncState, stateNew: SyncState) {
-    const ditto = this.ditto
-    const dittoHandle = Bridge.ditto.handleFor(ditto)
-    ditto.deferClose(() => {
-      const websocketURLs = stateNew.effectiveTransportConfig.connect.websocketURLs
-      const routingHint = stateNew.effectiveTransportConfig.global.routingHint
-      FFI.dittoSetStaticWebsocketClients(dittoHandle.deref(), websocketURLs, routingHint)
-    })
-  }
-
-  private updateGlobal(stateOld: SyncState, stateNew: SyncState) {
-    const ditto = this.ditto
-    const dittoHandle = Bridge.ditto.handleFor(ditto)
-    ditto.deferClose(() => {
-      if (stateOld.effectiveTransportConfig.global.syncGroup !== stateNew.effectiveTransportConfig.global.syncGroup) {
-        FFI.dittoSetSyncGroup(dittoHandle.deref(), stateNew.effectiveTransportConfig.global.syncGroup)
-      }
-    })
-  }
-
-  private updateConnectRetryInterval(stateOld: SyncState, stateNew: SyncState) {
-    const ditto = this.ditto
-    const dittoHandle = Bridge.ditto.handleFor(ditto)
-    ditto.deferClose(() => {
-      FFI.dittoSetConnectRetryInterval(dittoHandle.deref(), stateNew.effectiveTransportConfig.connect.retryInterval)
-    })
-  }
-}
-
-/**
- * Computes the effective transport config given a desired transport config and
- * some additional state.
- *
- * Disables all transports that are unavailable due to the runtime environment
- * or authentication requirements. Adds websocket URL for Ditto Cloud if
- * enabled.
- *
- * Throws if the target transport config enables sync but contains transports
- * that are not available in the current environment. Does not throw when
- * transports are enabled but not available due to authentication requirements.
- *
- * @private
- */
-function stateFrom(parameters: SyncParameters): SyncState {
-  // IMPORTANT: this function maps a set of sync parameters to an effective
-  // transport config plus some extra state where need be. Make sure
-  // to keep this function free of side-effects.
-
-  const identity = parameters.identity
-
-  const isSyncActive = parameters.isSyncActive
-  const isX509Valid = parameters.isX509Valid
-  const isWebValid = parameters.isWebValid
-
-  let appID
-  let customDittoCloudURL
-  let isDittoCloudSyncEnabled = false
-
-  if (identity.type === 'onlinePlayground' || identity.type === 'onlineWithAuthentication') {
-    // NOTE: enableDittoCloudSync is true by default for any online identity.
-    appID = identity.appID
-    customDittoCloudURL = identity.customDittoCloudURL ?? null
-    isDittoCloudSyncEnabled = identity.enableDittoCloudSync ?? true
-  }
-
-  validateEnabledTransportsAvailable(parameters.ditto, parameters.transportConfig)
-
-  const transportConfig = parameters.transportConfig.copy()
-
-  if (!isSyncActive || !isX509Valid) {
-    transportConfig.peerToPeer.bluetoothLE.isEnabled = false
-    transportConfig.peerToPeer.awdl.isEnabled = false
-    transportConfig.peerToPeer.lan.isEnabled = false
-    transportConfig.listen.tcp.isEnabled = false
-    transportConfig.connect.tcpServers = []
-  }
-
-  if (!isSyncActive || !isWebValid) {
-    transportConfig.connect.websocketURLs = []
-  }
-
-  if (!isSyncActive) {
-    transportConfig.listen.http.isEnabled = false
-  }
-
-  // NOTE: we have to smuggle in an additional Ditto Cloud websocket URL to
-  // connect to if cloud sync is enabled.
-  if (isSyncActive && isWebValid && isDittoCloudSyncEnabled) {
-    // @ts-ignore To fix this type error, refactor using a switch
-    // statement, c.f.
-    // https://github.com/getditto/ditto/blob/d35b6c1cb280cdd6368d14137c97609b9b9b9296/js/sources/sync.ts#L488
-    const dittoCloudURL = customDittoCloudURL ?? defaultDittoCloudURL(appID)
-    transportConfig.connect.websocketURLs.push(dittoCloudURL)
-  }
-
-  return {
-    underlyingSyncParameters: parameters,
-    effectiveTransportConfig: transportConfig.freeze(),
-  }
-}
-
-/**
- * Validate that all enabled transports are available in the current environment
- * and throw an error if not.
- *
- * @private
- */
-function validateEnabledTransportsAvailable(ditto: Ditto, transportConfig: TransportConfig) {
-  const dittoHandle = Bridge.ditto.handleFor(ditto)
-  return ditto.deferClose(() => {
-    // - BLE
-    // - AWDL
-    // - LAN / mDNS
-
-    const unavailableButEnabledP2PTransports = []
-
-    const isBLEAvailable = FFI.transportsBLEIsAvailable(dittoHandle.deref())
-    const isAWDLAvailable = FFI.transportsAWDLIsAvailable(dittoHandle.deref())
-    const isLANAvailable = FFI.transportsLANIsAvailable(dittoHandle.deref())
-
-    if (transportConfig.peerToPeer.bluetoothLE.isEnabled && !isBLEAvailable) {
-      unavailableButEnabledP2PTransports.push('BluetoothLE')
-    }
-
-    if (transportConfig.peerToPeer.awdl.isEnabled && !isAWDLAvailable) {
-      unavailableButEnabledP2PTransports.push('AWDL')
-    }
-
-    if (transportConfig.peerToPeer.lan.isEnabled && !isLANAvailable) {
-      unavailableButEnabledP2PTransports.push('LAN')
-    }
-
-    if (unavailableButEnabledP2PTransports.length > 0) {
-      throw new Error(`The following P2P transports are enabled in the transport config but are not supported in the current environment: ${unavailableButEnabledP2PTransports.join(', ')}`)
-    }
-
-    // - Websocket / HTTP
-    // - TCP
-
-    if (transportConfig.connect.tcpServers.length > 0 && Environment.isWebBuild) {
-      throw new Error(`The transport config contains TCP servers, but this transport is not supported in web environments`)
-    }
-
-    if (transportConfig.listen.http.isEnabled && Environment.isWebBuild) {
-      throw new Error(`The transport config contains an HTTP listener, which is not supported in web environments`)
-    }
-
-    if (transportConfig.listen.tcp.isEnabled && Environment.isWebBuild) {
-      throw new Error(`The transport config contains a TCP listener, which is not supported in web environments`)
-    }
-  })
-}

package/react-native/src/sources/test-helpers.ts

@@ -1,24 +0,0 @@
-import { Bridge } from './bridge'
-
-/**
- * Get a count of bridged objects binned by bridge type.
- *
- * Use this in testing to ensure that all objects are properly garbage collected at the end of tests.
- *
- * @returns an object with a key per bridge type, set to the count of registered
- * objects.
- */
-export function getBridgeLoad(): { [bridgeName: string]: number } {
-  const countsByType: { [bridgeName: string]: number } = {}
-  Bridge.all.map((bridgeWeakRef) => {
-    const bridge = bridgeWeakRef.deref()
-    if (!bridge) {
-      return null
-    }
-    if (bridge.count === 0) {
-      return null
-    }
-    countsByType[bridge.type.name] = bridge.count
-  })
-  return countsByType
-}

package/react-native/src/sources/transport-conditions-manager.ts

@@ -1,104 +0,0 @@
-//
-// Copyright © 2021 DittoLive Incorporated. All rights reserved.
-//
-
-import * as FFI from './ffi'
-
-import { Bridge } from './bridge'
-import { ObserverManager } from './observer-manager'
-
-import type { Ditto, TransportCondition, ConditionSource } from './ditto'
-
-/** @internal */
-export class TransportConditionsManager extends ObserverManager {
-  readonly ditto: Ditto
-
-  constructor(ditto: Ditto) {
-    const keepAlive = ditto.keepAlive
-    super('TransportConditionsObservation', { keepAlive })
-    this.ditto = ditto
-  }
-
-  protected register(callback: (...args: any[]) => void) {
-    const ditto = this.ditto
-    const dittoHandle = Bridge.ditto.handleFor(ditto)
-    return ditto.deferClose(() => {
-      return FFI.dittoRegisterTransportConditionChangedCallback(dittoHandle.deref(), callback)
-    })
-  }
-
-  protected unregister() {
-    const ditto = this.ditto
-    const dittoHandle = Bridge.ditto.handleFor(ditto)
-    return ditto.deferClose(() => {
-      return FFI.dittoRegisterTransportConditionChangedCallback(dittoHandle.deref(), null)
-    })
-  }
-
-  protected process(conditionSource: FFI.ConditionSource, transportCondition: FFI.TransportCondition): [TransportCondition, ConditionSource] {
-    /* eslint-disable */
-    let apiConditionSource: ConditionSource
-    switch (conditionSource) {
-      case 'Bluetooth':
-        apiConditionSource = 'BLE'
-        break
-      case 'Tcp':
-        apiConditionSource = 'TCP'
-        break
-      case 'Awdl':
-        apiConditionSource = 'AWDL'
-        break
-      case 'Mdns':
-        apiConditionSource = 'MDNS'
-        break
-    }
-    /* eslint-enable */
-
-    /* eslint-disable */
-    let apiTransportCondition: TransportCondition
-    switch (transportCondition) {
-      case 'Unknown':
-        apiTransportCondition = 'Unknown'
-        break
-      case 'Ok':
-        apiTransportCondition = 'OK'
-        break
-      case 'GenericFailure':
-        apiTransportCondition = 'GenericFailure'
-        break
-      case 'AppInBackground':
-        apiTransportCondition = 'AppInBackground'
-        break
-      case 'MdnsFailure':
-        apiTransportCondition = 'MDNSFailure'
-        break
-      case 'TcpListenFailure':
-        apiTransportCondition = 'TCPListenFailure'
-        break
-      case 'NoBleCentralPermission':
-        apiTransportCondition = 'NoBLECentralPermission'
-        break
-      case 'NoBlePeripheralPermission':
-        apiTransportCondition = 'NoBLEPeripheralPermission'
-        break
-      case 'CannotEstablishConnection':
-        apiTransportCondition = 'CannotEstablishConnection'
-        break
-      case 'BleDisabled':
-        apiTransportCondition = 'BLEDisabled'
-        break
-      case 'NoBleHardware':
-        apiTransportCondition = 'NoBLEHardware'
-        break
-      case 'WifiDisabled':
-        apiTransportCondition = 'WiFiDisabled'
-        break
-      case 'TemporarilyUnavailable':
-        apiTransportCondition = 'TemporarilyUnavailable'
-        break
-    }
-    /* eslint-enable */
-
-    return [apiTransportCondition, apiConditionSource]
-  }
-}