@dittolive/ditto 4.7.3 → 4.7.4-rc.2

package/react-native/src/sources/small-peer-info.ts

@@ -1,166 +0,0 @@
-//
-// Copyright © 2023 DittoLive Incorporated. All rights reserved.
-//
-
-import * as FFI from './ffi'
-import { Bridge } from './bridge'
-
-import type { Ditto } from './ditto'
-
-/**
- * Specifies which peers to replicate the small peer info to when enabled.
- *
- * Possible values are:
- *
- * - `LocalPeerOnly`: no replication (default)
- * - `BigPeerOnly`: replicate to the Big Peer
- */
-export type SmallPeerInfoSyncScope = 'LocalPeerOnly' | 'BigPeerOnly'
-
-/**
- * The entrypoint for small peer user info collection. Small peer info consists
- * of information gathered into a system collection on a regular interval and
- * optionally synced to the Big Peer for device dashboard and debugging
- * purposes.
- *
- * An instance of this class is available on each `Ditto` instance via its
- * {@link Ditto.smallPeerInfo | `smallPeerInfo`} property. Instantiating this
- * class directly is not supported.
- */
-export class SmallPeerInfo {
-  /**
-   * Indicates whether small peer info collection is currently enabled, defaults
-   * to `false`.
-   *
-   * **Note**: whether the background ingestion process is enabled or not is a
-   * separate decision to whether this information is allowed to sync to other
-   * peers (including the big peer). This is controlled by
-   * {@link getSyncScope | getSyncScope()} and
-   * {@link setSyncScope | setSyncScope()}.
-   */
-  get isEnabled(): boolean {
-    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
-    return this.ditto.deferClose(() => {
-      return FFI.dittoSmallPeerInfoGetIsEnabled(dittoHandle.deref())
-    })
-  }
-
-  /**
-   * Set whether small peer info collection is enabled.
-   *
-   * @throws when set to a non-boolean value.
-   */
-  set isEnabled(newValue: boolean) {
-    if (typeof newValue !== 'boolean') {
-      throw new TypeError(`Expected boolean, got ${typeof newValue}`)
-    }
-
-    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
-    void this.ditto.deferCloseAsync(async () => {
-      return FFI.dittoSmallPeerInfoSetEnabled(dittoHandle.deref(), newValue)
-    })
-  }
-
-  /**
-   * The metadata associated with the small peer info.
-   *
-   * Small peer info metadata is a free-form, user-provided JSON object that
-   * is inserted into the small peer info system document at each collection
-   * interval.
-   */
-  get metadata(): Record<string, any> {
-    return JSON.parse(this.metadataJSONString)
-  }
-
-  /**
-   * Set the metadata associated with the small peer info.
-   *
-   * The metadata must be a JSON-serializable object that conforms to the
-   * following constraints:
-   *
-   * - Must be a JSON object (not an array, string, number, etc.)
-   * - The size when encoded as JSON must be less than 128 KB
-   * - May only be nested up to 64 levels deep
-   *
-   * @example <caption>Valid metadata</caption>
-   * ditto.smallPeerInfo.metadata = {
-   *  "foo": "bar",
-   *  "nested": {
-   *    "inner": "value"
-   *   }
-   * }
-   *
-   * @throws when set to a value that violates any of the constraints listed
-   * above.
-   */
-  set metadata(metadata: Record<string, any>) {
-    this.metadataJSONString = JSON.stringify(metadata)
-  }
-
-  /**
-   * The metadata associated with the small peer info, as a JSON string.
-   */
-  get metadataJSONString(): string {
-    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
-    return this.ditto.deferClose(() => {
-      return FFI.dittoSmallPeerInfoGetMetadata(dittoHandle.deref())
-    })
-  }
-
-  /**
-   * Set the metadata associated with the small peer info, as a JSON string.
-   *
-   * @see {@link SmallPeerInfo.metadata | `metadata`} for more information on
-   * valid values.
-   * @throws when set to a value that violates any of the constraints listed in
-   * {@link SmallPeerInfo.metadata | `metadata`}.
-   */
-  set metadataJSONString(metadata: string) {
-    if (typeof metadata !== 'string') {
-      throw new TypeError(`Expected string, got ${typeof metadata}`)
-    }
-    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
-    this.ditto.deferClose(() => {
-      // throws if any validation errors occur
-      FFI.dittoSmallPeerInfoSetMetadata(dittoHandle.deref(), metadata)
-    })
-  }
-
-  /**
-   * Determines which "kind" of peers the small peer info will be
-   * replicated to.
-   *
-   * Defaults to `LocalPeerOnly`, which means no replication. Set this to
-   * `BigPeerOnly` to replicate collected info to the Big Peer.
-   */
-  async getSyncScope(): Promise<SmallPeerInfoSyncScope> {
-    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
-    return this.ditto.deferCloseAsync(async () => {
-      return FFI.dittoSmallPeerInfoGetSyncScope(dittoHandle.deref())
-    })
-  }
-
-  /**
-   * Set the sync scope.
-   *
-   * See {@link getSyncScope} for more information.
-   *
-   * @param syncScope the new sync scope.
-   * @throws when set to a value other than `BigPeerOnly` or `LocalPeerOnly`.
-   */
-  async setSyncScope(syncScope: SmallPeerInfoSyncScope): Promise<void> {
-    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
-    return this.ditto.deferCloseAsync(async () => {
-      return FFI.dittoSmallPeerInfoSetSyncScope(dittoHandle.deref(), syncScope as any)
-    })
-  }
-
-  // ----------------------------------------------------------- Internal ------
-
-  private ditto: Ditto
-
-  /** @internal */
-  constructor(ditto: Ditto) {
-    this.ditto = ditto
-  }
-}

package/react-native/src/sources/static-tcp-client.ts

@@ -1,8 +0,0 @@
-//
-// Copyright © 2021 DittoLive Incorporated. All rights reserved.
-//
-
-// HACK: don't export these publicly, only needed internally.
-
-/** @internal */
-export class StaticTCPClient {}

package/react-native/src/sources/store-observer.ts

@@ -1,170 +0,0 @@
-//
-// Copyright © 2023 DittoLive Incorporated. All rights reserved.
-//
-
-import * as FFI from './ffi'
-
-import { desugarJSObject } from './augment'
-import { Bridge } from './bridge'
-import { CBOR } from './cbor'
-import { DittoError, mapFFIErrors } from './error'
-import { Logger } from './logger'
-import { QueryResult } from './query-result'
-
-import type { Ditto } from './ditto'
-import type { DQLQueryArguments } from './essentials'
-import type { Store } from './store'
-
-/**
- * A store observation handler is called whenever an active store observer
- * receives new results.
- */
-export type StoreObservationHandler = (queryResult: QueryResult) => void
-
-/**
- * A store observation handler is called whenever an active store observer
- * receives new results.
- *
- * Call `signalNext()` to signal that the handler is ready to receive the next
- * callback from the store observer.
- */
-export type StoreObservationHandlerWithSignalNext = (queryResult: QueryResult, signalNext: () => void) => void
-
-/**
- * A store observer invokes a given handler whenever results for its query
- * change.
- *
- * The store observer will remain active until it is {@link cancel | cancelled},
- * or the Ditto instance managing the observer has been
- * {@link Ditto.close | closed}.
- *
- * Create a store observer by calling
- * {@link Store.registerObserver | `ditto.store.registerObserver()`}.
- */
-export class StoreObserver {
-  /**
-   * The Ditto instance this store observer is registered with.
-   */
-  readonly ditto: Ditto
-
-  /**
-   * The query string of the store observer (as passed when registering it).
-   */
-  readonly queryString: string
-
-  /**
-   * The query arguments of the store observer (as passed when registering it).
-   */
-  readonly queryArguments?: Readonly<DQLQueryArguments>
-
-  /**
-   * Convenience property, returns `true` once the store observer has been
-   * cancelled.
-   */
-  get isCancelled(): boolean {
-    return this._isCancelled
-  }
-
-  /**
-   * Cancels the store observer and unregisters it. No-op if the
-   * store observer has already been cancelled.
-   */
-  cancel() {
-    if (this._isCancelled) return
-    this._isCancelled = true
-    this.ditto.store.unregisterObserver(this)
-  }
-
-  // --------------------------- Internal -------------------------------------
-
-  /**
-   * The ID of this observer's live query.
-   *
-   * @internal
-   */
-  readonly liveQueryID: number
-
-  /** @internal */
-  constructor(ditto: Ditto, query: string, queryArguments: DQLQueryArguments | null, observationHandler: StoreObservationHandlerWithSignalNext) {
-    this.queryString = query
-    this.queryArguments = queryArguments ? Object.freeze({ ...queryArguments }) : undefined
-    this.ditto = ditto
-
-    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')
-      }
-    }
-    let storeObserverID: number | undefined
-    const dittoHandle = Bridge.ditto.handleFor(ditto)
-    this.ditto.deferClose(() => {
-      const weakThis = new WeakRef(this)
-
-      function wrappedObservationHandler(cCBParams: CCallbackParams): void {
-        const strongThis = weakThis.deref()
-        if (strongThis == null) {
-          Logger.debug(`Ignoring change event received by store observer ${storeObserverID} after it was cancelled`)
-          return
-        }
-
-        const result = Bridge.queryResult.bridge(cCBParams.query_result, () => new QueryResult(cCBParams.query_result))
-
-        Logger.debug(`Invoking user event handler with new event for store observer ${storeObserverID}`)
-        observationHandler(result, () => {
-          return strongThis.signalNext()
-        })
-      }
-
-      mapFFIErrors(() => {
-        storeObserverID = FFI.tryExperimentalRegisterChangeObserver(dittoHandle.deref(), query, queryArgumentsCBOR, wrappedObservationHandler)
-      })
-    })
-
-    if (storeObserverID == null) {
-      throw new DittoError('internal', 'Internal inconsistency, store observer ID is undefined after registering')
-    }
-
-    this.liveQueryID = storeObserverID
-  }
-
-  // --------------------------- Private --------------------------------------
-
-  /**
-   * `true` when the store observer has been cancelled.
-   *
-   * We mark the store observer as cancelled here as an optimization to avoid a
-   * scan of all store observers in the store whenever the `isCancelled`
-   * property is checked.
-   */
-  private _isCancelled = false
-
-  /**
-   * Signals to Ditto Core that the observer is ready for the next event.
-   */
-  private signalNext() {
-    const ditto = this.ditto
-    if (!ditto || ditto.isClosed) return
-
-    const dittoHandle = Bridge.ditto.handleFor(ditto)
-    const dittoPointer = dittoHandle.derefOrNull()
-    if (!dittoPointer) return
-
-    if (this.liveQueryID == null) {
-      throw new Error('live query ID is null while signaling ready for next event')
-    }
-
-    return ditto.deferCloseAsync(async () => {
-      Logger.debug(`Signaling availability for live query ${this.liveQueryID}`)
-      await FFI.liveQuerySignalAvailableNext(dittoPointer, this.liveQueryID)
-    })
-  }
-}
-
-// c.f. struct c_cb_params
-type CCallbackParams = {
-  query_result: FFI.Pointer<FFI.FFIQueryResult>
-}