@dittolive/ditto 4.5.1-experimental.aarch64-linux.1.aarch64 → 4.5.2-rc.2

package/react-native/lib/typescript/ditto.rn.d.ts

@@ -0,0 +1,15 @@
+import { type Permission } from 'react-native';
+import 'fastestsmallesttextencoderdecoder';
+export declare function ditto_sdk_transports_init(transportsErrorPointer: any): boolean;
+/**
+ * Get the list of missing Android permissions for syncing. The returned value
+ * can be passed directly to `PermissionsAndroid.requestMultiple()`.
+ *
+ * Returns an empty array on other platforms.
+ */
+export declare function getMissingAndroidPermissions(): Permission[];
+export declare function boxCStringIntoString(something: any): any;
+export declare function boxCBytesIntoBuffer(cborBytes: any): Uint8Array | null;
+export declare function getDeadlockTimeout(): number;
+export declare function setDeadlockTimeout(something: any): any;
+//# sourceMappingURL=ditto.rn.d.ts.map

package/react-native/lib/typescript/ditto.rn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ditto.rn.d.ts","sourceRoot":"","sources":["../../src/ditto.rn.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAOxE,OAAO,mCAAmC,CAAC;AAuE3C,wBAAgB,yBAAyB,CACvC,sBAAsB,EAAE,GAAG,GAC1B,OAAO,CAUT;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,IAAI,UAAU,EAAE,CAK3D;AAMD,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,GAAG,OAElD;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,GAAG,qBAGjD;AAED,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,GAAG,OAEhD"}

package/react-native/lib/typescript/index.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

package/react-native/lib/typescript/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":""}

package/react-native/src/ditto.rn.ts

@@ -0,0 +1,91 @@
+import { NativeModules, Platform, type Permission } from 'react-native';
+import { FinalizationGroup } from '@ungap/weakrefs';
+import 'fastestsmallesttextencoderdecoder';
+
+interface JSSDKAPI {
+  ditto_sdk_transports_init(transportsErrorPointer: any): boolean;
+}
+interface PlatformSpecificAPI {
+  getRandomValues<T extends ArrayBufferView>(array: T): T;
+  ditto_tick(): void;
+  createDirectory(path: string): string;
+  checkDirectoryExists(path: string): string;
+  getDeviceName(): string;
+
+  ditto_sdk_transports_set_android_context(): boolean;
+  ditto_sdk_transports_android_missing_permissions(): string[];
+}
+
+type DittoCoreType = JSSDKAPI & PlatformSpecificAPI;
+
+const dittoCore = global as unknown as DittoCoreType;
+const isLoaded = typeof dittoCore.getDeviceName === 'function';
+if (!isLoaded) {
+  const result = NativeModules.DittoRNSDK?.install();
+
+  if (!result) {
+    throw new Error('JSI bindings were not installed for: DittoRNSDK Module');
+  }
+
+  setInterval(() => {
+    dittoCore.ditto_tick();
+  }, 50);
+
+  if (
+    typeof global.FinalizationRegistry === 'undefined' &&
+    typeof FinalizationGroup !== 'undefined'
+  ) {
+    global.FinalizationRegistry = FinalizationGroup;
+  }
+}
+
+Object.keys(dittoCore)
+  .filter((key) => key !== 'ditto_sdk_transports_init')
+  .forEach((key) => {
+    exports[key] = dittoCore[key as keyof DittoCoreType];
+  });
+
+export function ditto_sdk_transports_init(
+  transportsErrorPointer: any
+): boolean {
+  if (Platform.OS === 'android') {
+    const res = dittoCore.ditto_sdk_transports_set_android_context();
+    if (!res) {
+      throw new Error(
+        "Couldn't manage to set Android context with `ditto_sdk_transports_set_android_context()`"
+      );
+    }
+  }
+
+  return dittoCore.ditto_sdk_transports_init(transportsErrorPointer);
+}
+
+/**
+ * Get the list of missing Android permissions for syncing. The returned value
+ * can be passed directly to `PermissionsAndroid.requestMultiple()`.
+ *
+ * Returns an empty array on other platforms.
+ */
+export function getMissingAndroidPermissions(): Permission[] {
+  if (Platform.OS !== 'android') {
+    return [];
+  }
+  return dittoCore.ditto_sdk_transports_android_missing_permissions() as Permission[];
+}
+
+export function boxCStringIntoString(something: any) {
+  return something;
+}
+
+export function boxCBytesIntoBuffer(cborBytes: any) {
+  const bytes = dittoCore.sliceBoxedToUInt8Array(cborBytes);
+  return bytes ? new Uint8Array(bytes) : null;
+}
+
+export function getDeadlockTimeout(): number {
+  return 0;
+}
+
+export function setDeadlockTimeout(something: any) {
+  return something;
+}

package/react-native/src/environment/environment.fallback.ts

@@ -0,0 +1,4 @@
+export const isReactNativeBuild = true
+export const isNodeBuild = false
+export const isWebBuild = false
+

package/react-native/src/index.ts

@@ -0,0 +1,26 @@
+
+export { getMissingAndroidPermissions } from './ditto.rn';
+
+export * from './sources/essentials';
+
+export * from './sources/logger';
+export * from './sources/document-id';
+export * from './sources/observer';
+
+export * from './sources/authenticator';
+export * from './sources/identity';
+export * from './sources/ditto';
+export * from './sources/store-observer';
+export * from './sources/sync';
+export * from './sources/sync-subscription';
+export * from './sources/error';
+export * from './sources/error-codes';
+export * from './sources/query-result-item';
+export * from './sources/query-result';
+
+export * from './sources/small-peer-info';
+export * from './sources/store';
+export * from './sources/presence';
+export * from './sources/transport-config';
+
+export * from './sources/epilogue';

package/react-native/src/sources/@cbor-redux.ts

@@ -0,0 +1,2 @@
+import * as CBOR from 'cbor-js';
+export {CBOR};

package/react-native/src/sources/@ditto.core.ts

@@ -0,0 +1 @@
+export * from '../ditto.rn';

package/react-native/src/sources/@environment.ts

@@ -0,0 +1 @@
+export * from '../environment/environment.fallback';

package/react-native/src/sources/attachment-fetch-event.ts

@@ -0,0 +1,54 @@
+//
+// Copyright © 2021 DittoLive Incorporated. All rights reserved.
+//
+
+import type { Attachment } from './attachment'
+
+/**
+ * The types of attachment fetch events that can be delivered to an attachment
+ * fetcher's `callback`.
+ */
+export type AttachmentFetchEventType = 'Completed' | 'Progress' | 'Deleted'
+
+/**
+ * An attachment fetch event used when the attachment's download has completed.
+ */
+export type AttachmentFetchEventCompleted = {
+  type: 'Completed'
+  attachment: Attachment
+}
+
+/**
+ * An attachment fetch event used when the attachment's download progressed but
+ * is not yet complete.
+ */
+export type AttachmentFetchEventProgress = {
+  type: 'Progress'
+  totalBytes: number | BigInt
+  downloadedBytes: number | BigInt
+}
+
+/**
+ * An attachment fetch event used when the attachment is deleted.
+ */
+export type AttachmentFetchEventDeleted = {
+  type: 'Deleted'
+}
+
+/**
+ * A representation of the events that can occur in relation to an attachment
+ * fetch.
+ *
+ * There are three different attachment fetch events: `Completed`, `Progress`,
+ * or `Deleted`.
+ *
+ * There will be at most one `Completed` or `Deleted` event per attachment
+ * fetch. There can be many `Progress` events delivered for each attachment
+ * fetch.
+ *
+ * Updates relating to an attachment fetch are delivered by registering an
+ * {@link AttachmentFetcher} through a call to
+ * {@link Collection.fetchAttachment | fetchAttachment()} on a
+ * {@link Collection} instance.
+ */
+export type AttachmentFetchEvent = AttachmentFetchEventCompleted | AttachmentFetchEventProgress | AttachmentFetchEventDeleted

package/react-native/src/sources/attachment-fetcher-manager.ts

@@ -0,0 +1,144 @@
+//
+// Copyright © 2023 DittoLive Incorporated. All rights reserved.
+//
+
+import * as FFI from './ffi'
+
+import { AttachmentFetcher } from './attachment-fetcher'
+import { AttachmentToken } from './attachment-token'
+import { Bridge } from './bridge'
+import { Ditto } from './ditto'
+
+import type { AttachmentFetchEvent } from './attachment-fetch-event'
+
+/** @internal */
+type AttachmentFetcherContextInfo = {
+  attachmentFetcher: WeakRef<AttachmentFetcher>
+  // Attachment token is unique per attachment.
+  attachmentTokenID: Uint8Array
+  // This id is unique per attachment fetcher.
+  id: string
+  // Promise for a token that can be used to cancel the fetch. If `null`, the
+  // fetch has already completed, errored, or been canceled.
+  cancelTokenPromise: Promise<unknown | null> | null
+}
+
+/**
+ * Manages attachment fetchers to make sure we free all resources when the
+ * fetcher is garbage collected and to allow us to wait for freeing of
+ * ressources to be finished before the ditto instance is closed.
+ *
+ * @internal */
+export class AttachmentFetcherManager {
+  readonly ditto: Ditto
+
+  /** @internal */
+  constructor(ditto: Ditto) {
+    this.ditto = ditto
+  }
+
+  /**
+   * Start an attachment fetcher.
+   *
+   * @internal */
+  startAttachmentFetcher(token: AttachmentToken, eventHandler?: (attachmentFetchEvent: AttachmentFetchEvent) => void): AttachmentFetcher {
+    return this.ditto.deferClose(() => {
+      const attachmentFetcher = new AttachmentFetcher(this.ditto, token, this, eventHandler)
+
+      // Register in finalization registry.
+      const contextInfo: AttachmentFetcherContextInfo = {
+        id: attachmentFetcher.id,
+        attachmentTokenID: token.id,
+        cancelTokenPromise: attachmentFetcher.cancelTokenPromise,
+        attachmentFetcher: new WeakRef(attachmentFetcher),
+      }
+      this.finalizationRegistry.register(attachmentFetcher, contextInfo, attachmentFetcher)
+
+      // Keep a reference to the context info so that we can stop the fetcher.
+      this.contextInfoByID[attachmentFetcher.id] = contextInfo
+
+      // Prevent cancellation of the fetch once it was fulfilled or rejected.
+      const resetCancelToken = () => {
+        if (this.contextInfoByID[attachmentFetcher.id] != null) {
+          this.contextInfoByID[attachmentFetcher.id].cancelTokenPromise = null
+        }
+      }
+      attachmentFetcher.attachment.then(
+        (value) => {
+          resetCancelToken()
+          return value
+        },
+        (reason) => {
+          resetCancelToken()
+          return reason
+        },
+      )
+
+      // Keep the attachment fetcher alive until it is stopped.
+      this.ditto.keepAlive.retain(`AttachmentFetcher.${attachmentFetcher.id})`)
+
+      return attachmentFetcher
+    })
+  }
+
+  /**
+   * Stop an attachment fetcher and wait for it to be stopped.
+   *
+   * @internal */
+  async stopAttachmentFetcher(attachmentFetcher: AttachmentFetcher): Promise<void> {
+    this.finalizationRegistry.unregister(attachmentFetcher)
+    const contextInfo = this.contextInfoByID[attachmentFetcher.id]
+    if (contextInfo == null) {
+      throw new Error(`Internal inconsistency: cannot stop attachment fetcher ${attachmentFetcher.id}, which is not registered.`)
+    }
+    await this.stopWithContextInfo(contextInfo)
+  }
+
+  /**
+   * Closing the manager will cancel all attachment fetchers.
+   *
+   * @internal
+   */
+  close() {
+    this.ditto.deferCloseAsync(async () => {
+      const contextInfos = Object.values(this.contextInfoByID)
+      const stopped = contextInfos.map(async (contextInfo) => {
+        const attachmentFetcher = contextInfo.attachmentFetcher.deref()
+        if (attachmentFetcher != null) {
+          await this.stopAttachmentFetcher(attachmentFetcher)
+        }
+      })
+      await Promise.all(stopped)
+    })
+  }
+
+  // --- Private ---
+
+  private contextInfoByID: { [attachmentFetcherID: string]: AttachmentFetcherContextInfo } = {}
+
+  private finalizationRegistry: FinalizationRegistry<AttachmentFetcherContextInfo> = new FinalizationRegistry(this.stopWithContextInfo)
+
+  /**
+   * Stop the attachment fetcher without unregistering it from the finalization
+   * registry.
+   */
+  private stopWithContextInfo(contextInfo: AttachmentFetcherContextInfo): Promise<void> {
+    const dittoHandle = Bridge.ditto.handleFor(this.ditto)
+    return this.ditto.deferCloseAsync(async () => {
+      // Remove the manager's own record of the context info.
+      if (this.contextInfoByID[contextInfo.id] == null) {
+        throw new Error(`Internal inconsistency: attachment fetcher ${contextInfo.id} not found in active attachment fetchers.`)
+      }
+      delete this.contextInfoByID[contextInfo.id]
+
+      // Release the keep-alive.
+      this.ditto.keepAlive.release(`AttachmentFetcher.${contextInfo.id})`)
+
+      // Cancel the fetcher if it is still running.
+      const cancelToken = await contextInfo.cancelTokenPromise
+      if (cancelToken) {
+        FFI.dittoCancelResolveAttachment(dittoHandle.deref(), contextInfo.attachmentTokenID, cancelToken)
+      }
+    })
+  }
+}

package/react-native/src/sources/attachment-fetcher.ts

@@ -0,0 +1,134 @@
+//
+// Copyright © 2021 DittoLive Incorporated. All rights reserved.
+//
+
+import * as FFI from './ffi'
+import { Bridge } from './bridge'
+import { Attachment } from './attachment'
+import { AttachmentToken } from './attachment-token'
+import { generateEphemeralToken, step } from './internal'
+
+import type { AttachmentFetchEvent } from './attachment-fetch-event'
+import type { Ditto } from './ditto'
+import type { AttachmentFetcherManager } from './attachment-fetcher-manager'
+
+/**
+ * These objects are returned by calls to
+ * {@link Collection.fetchAttachment | fetchAttachment()} on {@link Collection}
+ * and allow you to stop an in-flight attachment fetch.
+ */
+export class AttachmentFetcher implements PromiseLike<Attachment | null> {
+  /**
+   * Returns a promise for the attachment that you can `await`. The promise
+   * resolves to either an attachment or `null` if the attachment has been
+   * deleted meanwhile. The promise is rejected if an error occurs during
+   * the fetch. Note that the `AttachmentFetcher` itself implementes
+   * `PromiseLike`, so you can `await` it directly.
+   */
+  readonly attachment: Promise<Attachment | null>
+
+  /**
+   * Stops fetching the associated attachment and cleans up any associated
+   * resources.
+   *
+   * Note that you are not required to call `stop()` once your attachment fetch
+   * operation has finished. The method primarily exists to allow you to cancel
+   * an attachment fetch request while it is ongoing if you no longer wish for
+   * the attachment to be made available locally to the device.
+   */
+  stop() {
+    // No need for synchronicity here: we let the "stop promise" float / run in
+    // a detached fashion since there is no point in awaiting the "stop
+    // signaling" itself.
+    step(async () => {
+      await this.manager.stopAttachmentFetcher(this)
+      if (this.rejectPendingFetch != null) {
+        this.rejectPendingFetch()
+      }
+    })
+  }
+
+  // --------------------------------------- Internal ------------------------
+
+  /** @internal */
+  readonly cancelTokenPromise: Promise<unknown | null> | null = null
+
+  /** @internal */
+  readonly ditto: Ditto
+
+  /** @internal */
+  readonly id: string
+
+  /** @internal */
+  readonly manager: AttachmentFetcherManager
+
+  /** @internal */
+  readonly token: AttachmentToken
+
+  /** @internal */
+  then<TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseLike<TResult1 | TResult2> {
+    return this.attachment.then(onfulfilled, onrejected)
+  }
+
+  /** @internal */
+  constructor(ditto: Ditto, token: AttachmentToken, manager: AttachmentFetcherManager, eventHandler?: (attachmentFetchEvent: AttachmentFetchEvent) => void) {
+    this.ditto = ditto
+    this.token = token
+    this.manager = manager
+    this.id = generateEphemeralToken()
+
+    const eventHandlerOrNoOp = eventHandler || function () {}
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+
+    this.attachment = new Promise((resolve, reject) => {
+      const onComplete = (attachmentHandlePointer: FFI.Pointer<FFI.AttachmentHandle>) => {
+        const attachment = new Attachment(this.ditto, this.token)
+        Bridge.attachment.bridge(attachmentHandlePointer, () => attachment)
+
+        eventHandlerOrNoOp({ type: 'Completed', attachment })
+
+        this.rejectPendingFetch = null
+        resolve(attachment)
+      }
+
+      const onProgress = (downloaded: number | BigInt, toDownload: number | BigInt) => {
+        eventHandlerOrNoOp({ type: 'Progress', totalBytes: toDownload, downloadedBytes: downloaded })
+      }
+
+      const onDelete = () => {
+        eventHandlerOrNoOp({ type: 'Deleted' })
+
+        this.rejectPendingFetch = null
+        resolve(null)
+      }
+
+      const onError = () => {
+        ;(err: any) => {
+          this.rejectPendingFetch = null
+          reject(err)
+        }
+      }
+
+      // The core doesn't call any of the handlers defined above when a fetch is
+      // cancelled through `this.stop()` so we use this function to reject the
+      // promise from the outside.
+      this.rejectPendingFetch = () => {
+        reject(new Error('Attachment fetch was canceled'))
+      }
+
+      // Not awaited yet; only needs to be fully resolved (and `await`ed over)
+      // when using the actual `cancelTokenPromise`, which only happens in
+      // `AttachmentFetcherManager.stopWithContextInfo()`.
+      // @ts-expect-error setting readonly property
+      this.cancelTokenPromise = FFI.dittoResolveAttachment(dittoHandle.deref(), token.id, { onComplete, onProgress, onDelete }, onError)
+    })
+  }
+
+  /**
+   * This function is defined while a fetch is in progress and is used to reject
+   * the promise `this.attachment` when the fetch is canceled.
+   *
+   * @internal
+   */
+  private rejectPendingFetch: (() => void) | null = null
+}

package/react-native/src/sources/attachment-token.ts

@@ -0,0 +1,48 @@
+//
+// Copyright © 2021 DittoLive Incorporated. All rights reserved.
+//
+
+import * as FFI from './ffi'
+
+/**
+ * Serves as a token for a specific attachment that you can pass to a call to
+ * {@link Collection.fetchAttachment | fetchAttachment()} on a
+ * {@link Collection}.
+ */
+export class AttachmentToken {
+  /** @internal */
+  readonly id: Uint8Array
+
+  /** @internal */
+  readonly len: number
+
+  /** @internal */
+  readonly metadata: { [key: string]: string }
+
+  /** @internal */
+  constructor(jsObj: object) {
+    const type = jsObj[FFI.DittoCRDTTypeKey]
+    if (type !== FFI.DittoCRDTType.attachment) {
+      throw new Error('Invalid attachment token')
+    }
+
+    const id = jsObj['_id']
+    if (!(id instanceof Uint8Array)) {
+      throw new Error('Invalid attachment token id')
+    }
+
+    const len = jsObj['_len']
+    if (typeof len !== 'number' || len < 0) {
+      throw new Error('Invalid attachment token length')
+    }
+
+    const meta = jsObj['_meta']
+    if (typeof meta !== 'object') {
+      throw new Error('Invalid attachment token meta')
+    }
+
+    this.id = id
+    this.len = len
+    this.metadata = meta
+  }
+}

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

@@ -0,0 +1,74 @@
+//
+// Copyright © 2021 DittoLive Incorporated. All rights reserved.
+//
+
+import * as FFI from './ffi'
+import { Bridge } from './bridge'
+import * as Environment from './@environment'
+
+import type { Ditto } from './ditto'
+import type { AttachmentToken } from './attachment-token'
+
+/**
+ * Represents an attachment and can be used to insert the associated attachment
+ * into a document at a specific key-path. You can't instantiate an attachment
+ * directly, please use the {@link Collection.newAttachment | newAttachment()}
+ * method of {@link Collection} instead.
+ */
+export class Attachment {
+  /** @internal */
+  readonly ditto: Ditto
+
+  /** @internal */
+  readonly token: AttachmentToken
+
+  /** The attachment's metadata. */
+  get metadata(): { [key: string]: string } {
+    return this.token.metadata
+  }
+
+  /**
+   * Returns the attachment's data.
+   */
+  getData(): Promise<Uint8Array> {
+    const ditto = this.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    return this.ditto.deferCloseAsync(async () => {
+      // if (Environment.isWebBuild) {
+      //   const attachmentHandle = Bridge.attachment.handleFor(this)
+      //   return await FFI.dittoGetCompleteAttachmentData(dittoHandle.deref(), attachmentHandle.deref())
+      // }
+
+      // if (Environment.isNodeBuild) {
+      //   const attachmentHandle = Bridge.attachment.handleFor(this)
+      //   const attachmentPath = FFI.dittoGetCompleteAttachmentPath(dittoHandle.deref(), attachmentHandle.deref())
+      //   const fs = require('fs').promises
+      //   return await fs.readFile(attachmentPath)
+      // }
+    })
+  }
+
+  /**
+   * Copies the attachment to the specified file path. Node-only,
+   * throws in the browser.
+   *
+   * @param path The path that the attachment should be copied to.
+   */
+  copyToPath(path: string): Promise<void> {
+    const ditto = this.ditto
+    const dittoHandle = Bridge.ditto.handleFor(ditto)
+    return this.ditto.deferCloseAsync(async () => {
+      if (Environment.isWebBuild) {
+        throw new Error(`Can't copy attachment to path, not available when running in the browser.`)
+      }
+
+    
+    })
+  }
+
+  /** @internal */
+  constructor(ditto: Ditto, token: AttachmentToken) {
+    this.ditto = ditto
+    this.token = token
+  }
+}