dexie-cloud-addon 4.2.5 → 4.3.2

package/dist/umd/dexie-cloud-client.d.ts

@@ -0,0 +1,23 @@
+import Dexie from 'dexie';
+import './extend-dexie-interface';
+import { DexieCloudSyncOptions } from './DexieCloudSyncOptions';
+import { SyncState } from './types/SyncState';
+import { DXCWebSocketStatus } from './DXCWebSocketStatus';
+import { UserLogin } from './db/entities/UserLogin';
+export { DexieCloudTable } from './DexieCloudTable';
+export * from './getTiedRealmId';
+export { DBRealm, DBRealmMember, DBRealmRole, DBSyncedObject, DBPermissionSet, } from 'dexie-cloud-common';
+export { resolveText } from './helpers/resolveText';
+export { Invite } from './Invite';
+export type { UserLogin, DXCWebSocketStatus, SyncState };
+export type { DexieCloudSyncOptions };
+export type { DexieCloudOptions, PeriodicSyncOptions } from './DexieCloudOptions';
+export * from './types/DXCAlert';
+export * from './types/DXCInputField';
+export * from './types/DXCUserInteraction';
+export { defineYDocTrigger } from './define-ydoc-trigger';
+export declare function dexieCloud(dexie: Dexie): void;
+export declare namespace dexieCloud {
+    var version: any;
+}
+export default dexieCloud;

package/dist/umd/errors/HttpError.d.ts

@@ -0,0 +1,5 @@
+export declare class HttpError extends Error {
+    httpStatus: number;
+    constructor(res: Response, message?: string);
+    get name(): string;
+}

package/dist/umd/extend-dexie-interface.d.ts

@@ -0,0 +1,23 @@
+import { DBRealm, DBRealmMember, DBRealmRole } from 'dexie-cloud-common';
+import { DexieCloudAPI } from './DexieCloudAPI';
+import { NewIdOptions } from './types/NewIdOptions';
+type Optional<T, Props extends keyof T> = Omit<T, Props> & Partial<T>;
+declare module 'dexie' {
+    interface Dexie {
+        cloud: DexieCloudAPI;
+        realms: Table<DBRealm, string, Optional<DBRealm, 'realmId' | 'owner'>>;
+        members: Table<DBRealmMember, string, Optional<DBRealmMember, 'id' | 'owner'>>;
+        roles: Table<DBRealmRole, [string, string], Optional<DBRealmRole, 'owner'>>;
+    }
+    interface Table {
+        newId(options: NewIdOptions): string;
+        idPrefix(): string;
+    }
+    interface DexieConstructor {
+        Cloud: {
+            (db: Dexie): void;
+            version: string;
+        };
+    }
+}
+export {};

package/dist/umd/getGlobalRolesObservable.d.ts

@@ -0,0 +1,5 @@
+import Dexie from 'dexie';
+import { DBRealmRole } from 'dexie-cloud-common';
+export declare const getGlobalRolesObservable: (x: Dexie) => import("./mapValueObservable").ObservableWithCurrentValue<{
+    [roleName: string]: DBRealmRole;
+}>;

package/dist/umd/getInternalAccessControlObservable.d.ts

@@ -0,0 +1,12 @@
+import Dexie from 'dexie';
+import { DBRealm, DBRealmMember } from 'dexie-cloud-common';
+export type InternalAccessControlData = {
+    readonly selfMembers: DBRealmMember[];
+    readonly realms: DBRealm[];
+    readonly userId: string;
+};
+export declare const getInternalAccessControlObservable: (x: Dexie) => import("./mapValueObservable").ObservableWithCurrentValue<{
+    selfMembers: DBRealmMember[];
+    realms: DBRealm[];
+    userId: string;
+}>;

package/dist/umd/getInvitesObservable.d.ts

@@ -0,0 +1,23 @@
+import { Dexie } from 'dexie';
+export declare const getInvitesObservable: (x: Dexie) => import("./mapValueObservable").ObservableWithCurrentValue<{
+    accept(): Promise<void>;
+    reject(): Promise<void>;
+    id: string;
+    userId?: string;
+    email?: string;
+    name?: string;
+    invite?: boolean;
+    invitedDate?: Date;
+    invitedBy?: {
+        name: string;
+        email: string;
+        userId: string;
+    };
+    accepted?: Date;
+    rejected?: Date;
+    roles?: string[];
+    permissions?: import("dexie-cloud-common").DBPermissionSet;
+    realmId: string;
+    owner: string;
+    $ts?: number;
+}[]>;

package/dist/umd/getPermissionsLookupObservable.d.ts

@@ -0,0 +1,16 @@
+import Dexie from 'dexie';
+import { DBPermissionSet, DBRealm } from 'dexie-cloud-common';
+import { Observable } from 'rxjs';
+export type PermissionsLookup = {
+    [realmId: string]: DBRealm & {
+        permissions: DBPermissionSet;
+    };
+};
+export type PermissionsLookupObservable = Observable<PermissionsLookup> & {
+    getValue(): PermissionsLookup;
+};
+export declare const getPermissionsLookupObservable: (x: Dexie) => import("./mapValueObservable").ObservableWithCurrentValue<{
+    [x: string]: DBRealm & {
+        permissions: DBPermissionSet;
+    };
+}>;

package/dist/umd/getTiedRealmId.d.ts

@@ -0,0 +1,2 @@
+export declare function getTiedRealmId(objectId: string): string;
+export declare function getTiedObjectId(realmId: string): string | null;

package/dist/umd/helpers/BroadcastedAndLocalEvent.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from "rxjs";
+import { SWBroadcastChannel } from "./SWBroadcastChannel";
+export declare class BroadcastedAndLocalEvent<T> extends Observable<T> {
+    name: string;
+    bc: BroadcastChannel | SWBroadcastChannel;
+    constructor(name: string);
+    next(message: T): void;
+}

package/dist/umd/helpers/CancelToken.d.ts

@@ -0,0 +1,4 @@
+export interface CancelToken {
+    cancelled: boolean;
+}
+export declare function throwIfCancelled(cancelToken?: CancelToken): void;

package/dist/umd/helpers/IS_SERVICE_WORKER.d.ts

@@ -0,0 +1 @@
+export declare const IS_SERVICE_WORKER: false;

package/dist/umd/helpers/SWBroadcastChannel.d.ts

@@ -0,0 +1,12 @@
+/** This class is a fallback for browsers that lacks BroadcastChannel but have
+ * service workers (which is Safari versions 11.1 through 15.3).
+ * Safari 15.4 with BroadcastChannel was released on 2022-03-14.
+ * We might be able to remove this class in a near future as Safari < 15.4 is
+ * already very low in market share as of 2023-03-10.
+ */
+export declare class SWBroadcastChannel {
+    name: string;
+    constructor(name: string);
+    subscribe(listener: (message: any) => void): () => void;
+    postMessage(message: any): void;
+}

package/dist/umd/helpers/allSettled.d.ts

@@ -0,0 +1 @@
+export declare function allSettled(possiblePromises: any[]): Promise<unknown>;

package/dist/umd/helpers/bulkUpdate.d.ts

@@ -0,0 +1,4 @@
+import { Table } from 'dexie';
+export declare function bulkUpdate(table: Table, keys: any[], changeSpecs: {
+    [keyPath: string]: any;
+}[]): Promise<void>;

package/dist/umd/helpers/computeRealmSetHash.d.ts

@@ -0,0 +1,2 @@
+import { PersistedSyncState } from '../db/entities/PersistedSyncState';
+export declare function computeRealmSetHash({ realms, inviteRealms, }: PersistedSyncState): Promise<string>;

package/dist/umd/helpers/date-constants.d.ts

@@ -0,0 +1,5 @@
+export declare const SECONDS = 1000;
+export declare const MINUTES: number;
+export declare const HOURS: number;
+export declare const DAYS: number;
+export declare const WEEKS: number;

package/dist/umd/helpers/flatten.d.ts

@@ -0,0 +1 @@
+export declare function flatten<T>(a: (T | T[])[]): T[];

package/dist/umd/helpers/getMutationTable.d.ts

@@ -0,0 +1 @@
+export declare function getMutationTable(tableName: string): string;

package/dist/umd/helpers/getSyncableTables.d.ts

@@ -0,0 +1,4 @@
+import { Table } from "dexie";
+import { DexieCloudDB } from "../db/DexieCloudDB";
+import { EntityCommon } from "../db/entities/EntityCommon";
+export declare function getSyncableTables(db: DexieCloudDB): Table<EntityCommon>[];

package/dist/umd/helpers/getTableFromMutationTable.d.ts

@@ -0,0 +1 @@
+export declare function getTableFromMutationTable(mutationTable: string): string;

package/dist/umd/helpers/makeArray.d.ts

@@ -0,0 +1 @@
+export declare function makeArray<T>(iterable: Iterable<T>): T[];

package/dist/umd/helpers/randomString.d.ts

@@ -0,0 +1 @@
+export declare function randomString(bytes: number): string;

package/dist/umd/helpers/resolveText.d.ts

@@ -0,0 +1,16 @@
+import { DXCAlert } from "../types/DXCAlert";
+/** Resolve a message template with parameters.
+ *
+ * Example:
+ *  resolveText({
+ *    message: "Hello {name}!",
+ *    messageCode: "HELLO",
+ *    messageParams: {name: "David"}
+ *  }) => "Hello David!"
+ *
+ * @param message Template message with {vars} in it.
+ * @param messageCode Unique code for the message. Can be used for translation.
+ * @param messageParams Parameters to be used in the message.
+ * @returns A final message where parameters have been replaced with values.
+ */
+export declare function resolveText({ message, messageCode, messageParams }: DXCAlert): string;

package/dist/umd/helpers/throwVersionIncrementNeeded.d.ts

@@ -0,0 +1 @@
+export declare function throwVersionIncrementNeeded(): void;

package/dist/umd/helpers/visibilityState.d.ts

@@ -0,0 +1 @@
+export declare function createVisibilityStateObservable(): import("rxjs").Observable<DocumentVisibilityState>;

package/dist/umd/isEagerSyncDisabled.d.ts

@@ -0,0 +1,2 @@
+import { DexieCloudDB } from './db/DexieCloudDB';
+export declare function isEagerSyncDisabled(db: DexieCloudDB): boolean;

package/dist/umd/isFirefox.d.ts

@@ -0,0 +1 @@
+export declare const isFirefox: boolean;

package/dist/umd/isSafari.d.ts

@@ -0,0 +1,2 @@
+export declare const isSafari: boolean;
+export declare const safariVersion: number;

package/dist/umd/mapValueObservable.d.ts

@@ -0,0 +1,5 @@
+import { Observable } from 'rxjs';
+export interface ObservableWithCurrentValue<T> extends Observable<T> {
+    getValue(): T;
+}
+export declare function mapValueObservable<T, R>(o: ObservableWithCurrentValue<T>, mapper: (x: T) => R): ObservableWithCurrentValue<R>;

package/dist/umd/mergePermissions.d.ts

@@ -0,0 +1,2 @@
+import { DBPermissionSet } from 'dexie-cloud-common';
+export declare function mergePermissions(...permissions: DBPermissionSet[]): DBPermissionSet;

package/dist/umd/middleware-helpers/guardedTable.d.ts

@@ -0,0 +1,11 @@
+import { DBCoreTable } from "dexie";
+export declare function guardedTable(table: DBCoreTable): {
+    count: (req: import("dexie").DBCoreCountRequest) => Promise<number>;
+    get: (req: import("dexie").DBCoreGetRequest) => Promise<any>;
+    getMany: (req: import("dexie").DBCoreGetManyRequest) => Promise<any[]>;
+    openCursor: (req: import("dexie").DBCoreOpenCursorRequest) => Promise<import("dexie").DBCoreCursor | null>;
+    query: (req: import("dexie").DBCoreQueryRequest) => Promise<import("dexie").DBCoreQueryResponse>;
+    mutate: (req: import("dexie").DBCoreMutateRequest) => Promise<import("dexie").DBCoreMutateResponse>;
+    name: string;
+    schema: import("dexie").DBCoreTableSchema;
+};

package/dist/umd/middleware-helpers/idGenerationHelpers.d.ts

@@ -0,0 +1,18 @@
+import { DBCoreAddRequest, DBCoreDeleteRequest, DBCoreIndex, DBCorePutRequest } from 'dexie';
+export declare function toStringTag(o: Object): any;
+export declare function getEffectiveKeys(primaryKey: DBCoreIndex, req: (Pick<DBCoreAddRequest | DBCorePutRequest, 'type' | 'values'> & {
+    keys?: any[];
+}) | Pick<DBCoreDeleteRequest, 'keys' | 'type'>): any[];
+export declare function generateTablePrefix(tableName: string, allPrefixes: Set<string>): string;
+/**
+ *
+ * @param prefix A unique 3-letter short-name of the table.
+ * @param shardKey 3 last letters from another ID if colocation is requested. Verified on server on inserts - guarantees unique IDs across shards.
+ *  The shardKey part of the key represent the shardId where it was first created. An object with this
+ *  primary key can later on be moved to another shard without being altered. The reason for having
+ *  the origin shardKey as part of the key, is that the server will not need to check uniqueness constraint
+ *  across all shards on every insert. Updates / moves across shards are already controlled by the server
+ *  in the sense that the objects needs to be there already - we only need this part for inserts.
+ * @returns
+ */
+export declare function generateKey(prefix: string, shardKey?: string): string;

package/dist/umd/middlewares/createIdGenerationMiddleware.d.ts

@@ -0,0 +1,3 @@
+import { DBCore, Middleware } from 'dexie';
+import { DexieCloudDB } from '../db/DexieCloudDB';
+export declare function createIdGenerationMiddleware(db: DexieCloudDB): Middleware<DBCore>;

package/dist/umd/middlewares/createImplicitPropSetterMiddleware.d.ts

@@ -0,0 +1,3 @@
+import { DBCore, Middleware } from 'dexie';
+import { DexieCloudDB } from '../db/DexieCloudDB';
+export declare function createImplicitPropSetterMiddleware(db: DexieCloudDB): Middleware<DBCore>;

package/dist/umd/middlewares/createMutationTrackingMiddleware.d.ts

@@ -0,0 +1,17 @@
+import { DBCore, Middleware } from 'dexie';
+import { BehaviorSubject } from 'rxjs';
+import { DexieCloudDB } from '../db/DexieCloudDB';
+import { UserLogin } from '../db/entities/UserLogin';
+export interface MutationTrackingMiddlewareArgs {
+    currentUserObservable: BehaviorSubject<UserLogin>;
+    db: DexieCloudDB;
+}
+/** Tracks all mutations in the same transaction as the mutations -
+ * so it is guaranteed that no mutation goes untracked - and if transaction
+ * aborts, the mutations won't be tracked.
+ *
+ * The sync job will use the tracked mutations as the source of truth when pushing
+ * changes to server and cleanup the tracked mutations once the server has
+ * ackowledged that it got them.
+ */
+export declare function createMutationTrackingMiddleware({ currentUserObservable, db, }: MutationTrackingMiddlewareArgs): Middleware<DBCore>;

package/dist/umd/middlewares/outstandingTransaction.d.ts

@@ -0,0 +1,4 @@
+import { DBCoreTransaction } from 'dexie';
+import { BehaviorSubject } from 'rxjs';
+import { TXExpandos } from '../types/TXExpandos';
+export declare const outstandingTransactions: BehaviorSubject<Set<DBCoreTransaction & IDBTransaction & TXExpandos>>;

package/dist/umd/overrideParseStoresSpec.d.ts

@@ -0,0 +1,4 @@
+import Dexie, { DbSchema } from 'dexie';
+export declare function overrideParseStoresSpec(origFunc: Function, dexie: Dexie): (stores: {
+    [tableName: string]: string;
+}, dbSchema: DbSchema) => any;

package/dist/umd/performInitialSync.d.ts

@@ -0,0 +1,4 @@
+import { DexieCloudSchema } from 'dexie-cloud-common';
+import { DexieCloudDB } from './db/DexieCloudDB';
+import { DexieCloudOptions } from './DexieCloudOptions';
+export declare function performInitialSync(db: DexieCloudDB, cloudOptions: DexieCloudOptions, cloudSchema: DexieCloudSchema): Promise<void>;

package/dist/umd/permissions.d.ts

@@ -0,0 +1,9 @@
+import Dexie from 'dexie';
+import { Observable } from 'rxjs';
+import { PermissionChecker } from './PermissionChecker';
+import './extend-dexie-interface';
+export declare function permissions(dexie: Dexie, obj: {
+    owner?: string;
+    realmId?: string;
+    table?: () => string;
+}, tableName?: string): Observable<PermissionChecker<any>>;

package/dist/umd/prodLog.d.ts

@@ -0,0 +1,9 @@
+/** A way to log to console in production without terser stripping out
+ * it from the release bundle.
+ * This should be used very rarely and only in places where it's
+ * absolutely necessary to log something in production.
+ *
+ * @param level
+ * @param args
+ */
+export declare function prodLog(level: 'log' | 'warn' | 'error' | 'debug', ...args: any[]): void;

package/dist/umd/service-worker.d.ts

@@ -0,0 +1 @@
+export {};