@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/cjs/types/rx-change-event.d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rx-change-event.d.js","names":[],"sources":["../../../src/types/rx-change-event.d.ts"],"sourcesContent":["import type {\r\n    RxDocumentData,\r\n    RxStorageChangeEvent,\r\n    RxStorageDefaultCheckpoint\r\n} from './rx-storage.d.ts';\r\n\r\n\r\nexport type RxChangeEventBase<RxDocType> = {\r\n    operation: 'INSERT' | 'UPDATE' | 'DELETE';\r\n\r\n    readonly documentId: string;\r\n\r\n    // optional, does not exist on changes to localdocs of the database\r\n    readonly collectionName?: string;\r\n\r\n    // true if the event is about a local document, false if not.\r\n    readonly isLocal: boolean;\r\n\r\n    documentData: RxDocumentData<RxDocType>;\r\n};\r\n\r\nexport type RxChangeEventInsert<RxDocType> = RxChangeEventBase<RxDocType> & {\r\n    operation: 'INSERT';\r\n    previousDocumentData: undefined;\r\n};\r\n\r\nexport type RxChangeEventUpdate<RxDocType> = RxChangeEventBase<RxDocType> & {\r\n    operation: 'UPDATE';\r\n    previousDocumentData: RxDocumentData<RxDocType>;\r\n};\r\n\r\nexport type RxChangeEventDelete<RxDocType> = RxChangeEventBase<RxDocType> & {\r\n    operation: 'DELETE';\r\n    previousDocumentData: RxDocumentData<RxDocType>;\r\n};\r\n\r\nexport type RxChangeEvent<RxDocType> = RxChangeEventInsert<RxDocType> | RxChangeEventUpdate<RxDocType> | RxChangeEventDelete<RxDocType>;\r\n\r\n/**\r\n * Internally, all events are processed via bulks\r\n * to save performance when sending them over a transport layer\r\n * or de-duplicating them.\r\n */\r\nexport type RxChangeEventBulk<RxDocType, CheckpointType = RxStorageDefaultCheckpoint> = {\r\n    /**\r\n     * Unique id of the bulk,\r\n     * used to detect duplicate bulks\r\n     * that have already been processed.\r\n     */\r\n    id: string;\r\n\r\n    // optional, not given for changes to local documents of a RxDatabase.\r\n    collectionName?: string;\r\n\r\n    isLocal: boolean;\r\n\r\n    events: RxStorageChangeEvent<RxDocType>[];\r\n    /**\r\n     * Required for replication.\r\n     * Passing this checkpoint into getChangedDocumentsSince()\r\n     * must return all items that have been modified AFTER this write event.\r\n     */\r\n    checkpoint: CheckpointType;\r\n\r\n    /**\r\n     * The context that was given at the call to bulkWrite()\r\n     * that caused this EventBulk.\r\n     */\r\n    context: string;\r\n    /**\r\n     * Token of the database instance that created the events.\r\n     * Used to determine if the events came from another instance over the BroadcastChannel.\r\n     */\r\n    databaseToken: string;\r\n    /**\r\n     * The storageToken of the RxDatabase that created the events.\r\n     * Used to ensure we do not process events of other RxDatabases.\r\n     */\r\n    storageToken: string;\r\n    /**\r\n     * If true, the events belong to some internal stuff like from plugins.\r\n     * Internal events are not emitted to the outside over the .$ Observables.\r\n     */\r\n    internal: boolean;\r\n};\r\n"],"mappings":"","ignoreList":[]}

package/dist/cjs/types/rx-collection.d.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=rx-collection.d.js.map

package/dist/cjs/types/rx-collection.d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rx-collection.d.js","names":[],"sources":["../../../src/types/rx-collection.d.ts"],"sourcesContent":["import type {\r\n    RxJsonSchema,\r\n    RxDocument,\r\n    MigrationStrategies,\r\n    RxConflictHandler\r\n} from './index.d.ts';\r\nimport type {\r\n    RxCollectionBase\r\n} from '../rx-collection.d.ts';\r\nimport type { QueryCache } from '../query-cache.d.ts';\r\nimport type { RxLocalDocumentMutation } from './rx-database.d.ts';\r\n\r\nexport interface KeyFunctionMap {\r\n    [key: string]: Function;\r\n}\r\nexport interface NumberFunctionMap {\r\n    [key: number]: Function;\r\n}\r\n\r\n\r\n/**\r\n * Params to create a new collection.\r\n * Notice the name of the collection is set one level higher\r\n * when calling addCollections()\r\n */\r\nexport type RxCollectionCreator<RxDocType = any> = {\r\n    schema: RxJsonSchema<RxDocType>;\r\n    instanceCreationOptions?: any;\r\n    migrationStrategies?: MigrationStrategies;\r\n    autoMigrate?: boolean;\r\n    statics?: KeyFunctionMap;\r\n    methods?: KeyFunctionMap;\r\n    attachments?: KeyFunctionMap;\r\n    options?: any;\r\n    /**\r\n     * Set this to true if you want to store local documents\r\n     * in the RxCollection instance.\r\n     */\r\n    localDocuments?: boolean;\r\n    cacheReplacementPolicy?: RxCacheReplacementPolicy;\r\n\r\n    /**\r\n     * Depending on which plugins or storage is used,\r\n     * the RxCollection might need a way to resolve conflicts\r\n     * which is done by this conflict handler.\r\n     * If no conflict handler is provided, a master-always-wins handler\r\n     * will be used as default\r\n     */\r\n    conflictHandler?: RxConflictHandler<RxDocType>;\r\n};\r\n\r\nexport type RxCacheReplacementPolicy = (collection: RxCollection, queryCache: QueryCache) => void;\r\n\r\nexport type RxCollectionHookCallback<\r\n    RxDocumentType,\r\n    OrmMethods,\r\n    Reactivity\r\n> = (\r\n    data: RxDocumentType,\r\n    instance: RxDocument<RxDocumentType, OrmMethods, Reactivity>\r\n) => void | Promise<void> | any;\r\nexport type RxCollectionHookNoInstance<RxDocumentType> = (data: RxDocumentType) => void | Promise<void> | any;\r\nexport type RxCollectionHookCallbackNonAsync<RxDocumentType, OrmMethods, Reactivity> = (\r\n    data: RxDocumentType,\r\n    instance: RxDocument<RxDocumentType, OrmMethods, Reactivity>\r\n) => void | any;\r\nexport type RxCollectionHookNoInstanceCallback<\r\n    RxDocumentType,\r\n    OrmMethods,\r\n    Reactivity\r\n> = (\r\n    data: RxDocumentType,\r\n    instance: RxCollection<RxDocumentType, OrmMethods, Reactivity>\r\n) => Promise<void> | void | any;\r\n\r\nexport type RxCollection<\r\n    RxDocumentType = any,\r\n    OrmMethods = {},\r\n    StaticMethods = {},\r\n    InstanceCreationOptions = {},\r\n    Reactivity = unknown\r\n> = StaticMethods &\r\n    RxCollectionBase<InstanceCreationOptions, RxDocumentType, OrmMethods, StaticMethods, Reactivity> &\r\n    RxCollectionGenerated<RxDocumentType, OrmMethods, Reactivity>;\r\n\r\nexport interface RxCollectionGenerated<RxDocumentType = any, OrmMethods = {}, Reactivity = unknown> extends RxLocalDocumentMutation<RxCollection<RxDocumentType, OrmMethods, any, any, Reactivity>> {\r\n\r\n    // HOOKS\r\n    preInsert(fun: RxCollectionHookNoInstanceCallback<RxDocumentType, OrmMethods, Reactivity>, parallel: boolean): void;\r\n    preSave(fun: RxCollectionHookCallback<RxDocumentType, OrmMethods, Reactivity>, parallel: boolean): void;\r\n    preRemove(fun: RxCollectionHookCallback<RxDocumentType, OrmMethods, Reactivity>, parallel: boolean): void;\r\n    postInsert(fun: RxCollectionHookCallback<RxDocumentType, OrmMethods, Reactivity>, parallel: boolean): void;\r\n    postSave(fun: RxCollectionHookCallback<RxDocumentType, OrmMethods, Reactivity>, parallel: boolean): void;\r\n    postRemove(fun: RxCollectionHookCallback<RxDocumentType, OrmMethods, Reactivity>, parallel: boolean): void;\r\n    postCreate(fun: RxCollectionHookCallbackNonAsync<RxDocumentType, OrmMethods, Reactivity>): void;\r\n\r\n    // only inMemory-collections\r\n    awaitPersistence(): Promise<void>;\r\n}\r\n\r\n/**\r\n * Previously all properties were typed as any because they could be encrypted.\r\n * This is no longer needed so the type now preserves the original property types.\r\n */\r\nexport type RxDumpCollectionAsAny<T> = T;\r\n\r\ninterface RxDumpCollectionBase {\r\n    name: string;\r\n    passwordHash?: string;\r\n    schemaHash: string;\r\n}\r\nexport interface RxDumpCollection<RxDocumentType> extends RxDumpCollectionBase {\r\n    docs: RxDocumentType[];\r\n}\r\nexport interface RxDumpCollectionAny<RxDocumentType> extends RxDumpCollectionBase {\r\n    docs: RxDumpCollectionAsAny<RxDocumentType>[];\r\n}\r\n"],"mappings":"","ignoreList":[]}

package/dist/cjs/types/rx-database-internal-store.d.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=rx-database-internal-store.d.js.map

package/dist/cjs/types/rx-database-internal-store.d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rx-database-internal-store.d.js","names":[],"sources":["../../../src/types/rx-database-internal-store.d.ts"],"sourcesContent":["import type {\r\n    RxMigrationStatus\r\n} from '../plugins/migration-schema/index.ts';\r\nimport type { RxJsonSchema } from './rx-schema.d.ts';\r\n\r\nexport type InternalStoreDocType<Data = any> = {\r\n    id: string;\r\n    key: string;\r\n    context: string;\r\n    data: Data;\r\n};\r\n\r\n/**\r\n * Stores information about the collections.\r\n * The collection.name is the 'key' value.\r\n */\r\nexport type InternalStoreStorageTokenDocType = InternalStoreDocType<{\r\n    rxdbVersion: string;\r\n    token: string;\r\n    instanceToken: string;\r\n    passwordHash?: string;\r\n}>;\r\n\r\n/**\r\n * Stores information about the collections.\r\n * The collection.name is the 'key' value.\r\n */\r\nexport type InternalStoreCollectionDocType = InternalStoreDocType<{\r\n    /**\r\n     * Plain name of the collection\r\n     */\r\n    name: string;\r\n    schema: RxJsonSchema<any>;\r\n    schemaHash: string;\r\n    version: number;\r\n\r\n    /**\r\n     * Storages that are connected to this collection\r\n     * so that when the collection is removed,\r\n     * these storages must also be removed.\r\n     * For example the replication meta storage\r\n     * must be reset when the collection is removed.\r\n     */\r\n    connectedStorages: {\r\n        collectionName: string;\r\n        schema: RxJsonSchema<any>;\r\n    }[];\r\n\r\n    /**\r\n     * Contains the migration status\r\n     * only if a migration has been started.\r\n     */\r\n    migrationStatus?: RxMigrationStatus;\r\n}>;\r\n"],"mappings":"","ignoreList":[]}

package/dist/cjs/types/rx-database.d.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=rx-database.d.js.map

package/dist/cjs/types/rx-database.d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rx-database.d.js","names":[],"sources":["../../../src/types/rx-database.d.ts"],"sourcesContent":["import type {\r\n    RxCollection,\r\n    RxDumpCollection,\r\n    RxDumpCollectionAsAny\r\n} from './rx-collection.d.ts';\r\nimport type {\r\n    RxDatabaseBase\r\n} from '../rx-database.d.ts';\r\nimport { Observable } from 'rxjs';\r\nimport type { RxStorage } from './rx-storage.interface.d.ts';\r\nimport type { RxLocalDocument } from './plugins/local-documents.d.ts';\r\nimport type { RxCleanupPolicy } from './plugins/cleanup.d.ts';\r\nimport type { ById, HashFunction } from './util.d.ts';\r\nimport type { RxReactivityFactory } from './plugins/reactivity.d.ts';\r\n\r\nexport interface RxDatabaseCreator<Internals = any, InstanceCreationOptions = any, Reactivity = unknown> {\r\n    storage: RxStorage<Internals, InstanceCreationOptions>;\r\n    instanceCreationOptions?: InstanceCreationOptions;\r\n    name: string;\r\n    /**\r\n     * Typed as `any` because different encryption plugins\r\n     * may use passwords that are not strings.\r\n     */\r\n    password?: string | any;\r\n    multiInstance?: boolean;\r\n    eventReduce?: boolean;\r\n    ignoreDuplicate?: boolean;\r\n    options?: any;\r\n    cleanupPolicy?: Partial<RxCleanupPolicy>;\r\n    closeDuplicates?: boolean;\r\n    /**\r\n     * Set this to true if you want to store local documents\r\n     * in the RxDatabase instance.\r\n     */\r\n    localDocuments?: boolean;\r\n\r\n    /**\r\n     * Hash method used to hash strings and json-stringified objects.\r\n     * This hash does not have to be cryptographically secure,\r\n     * but it is very important that is does have not create\r\n     * collisions.\r\n     * Default is the sha256 from crypto.subtle.digest('SHA-256', data)\r\n     */\r\n    hashFunction?: HashFunction;\r\n\r\n    /**\r\n     * By default, count() queries in 'slow' mode are not allowed.\r\n     */\r\n    allowSlowCount?: boolean;\r\n\r\n    /**\r\n     * Can be used to add a custom reactivity Factory\r\n     * that is used on all getters and values that end with the double $$.\r\n     * For example you can use the signals api of your framework and vuejs ref()\r\n     */\r\n    reactivity?: RxReactivityFactory<Reactivity>;\r\n}\r\n\r\nexport type CollectionsOfDatabase = ById<RxCollection>;\r\nexport type RxDatabase<\r\n    Collections = CollectionsOfDatabase,\r\n    Internals = any,\r\n    InstanceCreationOptions = any,\r\n    Reactivity = any\r\n> = RxDatabaseBase<\r\n    Internals,\r\n    InstanceCreationOptions,\r\n    Collections,\r\n    Reactivity\r\n> & Collections & RxDatabaseGenerated<Collections, Reactivity>;\r\n\r\n\r\nexport interface RxLocalDocumentMutation<StorageType, Reactivity = unknown> {\r\n    insertLocal<LocalDocType = any>(id: string, data: LocalDocType): Promise<\r\n        RxLocalDocument<StorageType, LocalDocType, Reactivity>\r\n    >;\r\n    upsertLocal<LocalDocType = any>(id: string, data: LocalDocType): Promise<\r\n        RxLocalDocument<StorageType, LocalDocType, Reactivity>\r\n    >;\r\n    getLocal<LocalDocType = any>(id: string): Promise<\r\n        RxLocalDocument<StorageType, LocalDocType, Reactivity> | null\r\n    >;\r\n    getLocal$<LocalDocType = any>(id: string): Observable<\r\n        RxLocalDocument<StorageType, LocalDocType, Reactivity> | null\r\n    >;\r\n}\r\n\r\nexport interface RxDatabaseGenerated<Collections, Reactivity> extends RxLocalDocumentMutation<RxDatabase<Collections, any, any, Reactivity>> { }\r\n\r\n/**\r\n * Extract the **DocumentType** of a collection.\r\n */\r\ntype ExtractDTcol<P> = P extends RxCollection<infer T> ? T : { [prop: string]: any; };\r\n\r\ninterface RxDumpDatabaseBase {\r\n    instanceToken: string;\r\n    name: string;\r\n    passwordHash: string | null;\r\n}\r\nexport interface RxDumpDatabase<Col> extends RxDumpDatabaseBase {\r\n    collections: RxDumpCollection<ExtractDTcol<Col[keyof Col]>>[];\r\n}\r\nexport interface RxDumpDatabaseAny<Col> extends RxDumpDatabaseBase {\r\n    collections: RxDumpCollection<RxDumpCollectionAsAny<ExtractDTcol<Col[keyof Col]>>>[];\r\n}\r\n\r\n\r\n\r\nexport type RxCollectionCreatedEvent = {\r\n    type: 'ADDED';\r\n    collection: RxCollection;\r\n};\r\n\r\nexport type RxCollectionClosedEvent = {\r\n    type: 'CLOSED';\r\n    collection: RxCollection;\r\n};\r\n\r\n/**\r\n * Fired on RxDatabase.collection$\r\n */\r\nexport type RxCollectionEvent =\r\n    | RxCollectionCreatedEvent\r\n    | RxCollectionClosedEvent;\r\n"],"mappings":"","ignoreList":[]}

package/dist/cjs/types/rx-document.d.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=rx-document.d.js.map

package/dist/cjs/types/rx-document.d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rx-document.d.js","names":[],"sources":["../../../src/types/rx-document.d.ts"],"sourcesContent":["import {\r\n    Observable\r\n} from 'rxjs';\r\n\r\nimport type {\r\n    RxCollection,\r\n} from './rx-collection.d.ts';\r\nimport type {\r\n    RxAttachment,\r\n    RxAttachmentCreator,\r\n    RxAttachmentCreatorBase64\r\n} from './rx-attachment.d.ts';\r\nimport type { RxDocumentData, WithDeleted } from './rx-storage.d.ts';\r\nimport type { RxChangeEvent } from './rx-change-event.d.ts';\r\nimport type { DeepReadonly, MaybePromise, PlainJsonValue } from './util.d.ts';\r\nimport type { UpdateQuery } from './plugins/update.d.ts';\r\nimport type { CRDTEntry } from './plugins/crdt.d.ts';\r\nimport type { Reactified } from './plugins/reactivity.d.ts';\r\n\r\n\r\n\r\nexport type RxDocument<RxDocumentType = {}, OrmMethods = {}, Reactivity = unknown> = RxDocumentBase<\r\n    RxDocumentType,\r\n    OrmMethods,\r\n    Reactivity\r\n> & RxDocumentType & OrmMethods & ExtendObservables<RxDocumentType> & ExtendReactivity<RxDocumentType, Reactivity>;\r\n\r\n\r\n/**\r\n * Extend the base properties by the property$ fields\r\n * so it knows that RxDocument.age also has RxDocument.age$ which is\r\n * an observable.\r\n * TODO how to do this for the nested fields?\r\n */\r\ntype ExtendObservables<RxDocumentType> = {\r\n    [P in keyof RxDocumentType as `${string & P}$`]: Observable<RxDocumentType[P]>;\r\n};\r\n\r\ntype ExtendReactivity<RxDocumentType, Reactivity> = {\r\n    [P in keyof RxDocumentType as `${string & P}$$`]: Reactified<Reactivity, RxDocumentType[P]>;\r\n};\r\n\r\n/**\r\n * The public facing modify update function.\r\n * It only gets the document parts as input, that\r\n * are mutateable by the user.\r\n */\r\nexport type ModifyFunction<RxDocumentType> = (\r\n    doc: WithDeleted<RxDocumentType>\r\n) => MaybePromise<WithDeleted<RxDocumentType>> | MaybePromise<RxDocumentType>;\r\n\r\n/**\r\n * Meta data that is attached to each document by RxDB.\r\n */\r\nexport type RxDocumentMeta = {\r\n    /**\r\n     * Last write time.\r\n     * Unix epoch in milliseconds.\r\n     */\r\n    lwt: number;\r\n\r\n    /**\r\n     * The replication plugins \"tags\" the origin\r\n     * of writes to later know if a write came from\r\n     * the replication or was done locally.\r\n     */\r\n    o?: {\r\n        hash: string;\r\n        _rev: number;\r\n    };\r\n\r\n    /**\r\n     * Any other value can be attached to the _meta data.\r\n     * Mostly done by plugins to mark documents.\r\n     */\r\n    [k: string]: PlainJsonValue | undefined;\r\n\r\n\r\n};\r\n\r\nexport declare interface RxDocumentBase<RxDocType, OrmMethods = {}, Reactivity = unknown> {\r\n    isInstanceOfRxDocument: true;\r\n    collection: RxCollection<RxDocType, OrmMethods, Reactivity>;\r\n    readonly deleted: boolean;\r\n\r\n    readonly $: Observable<RxDocument<RxDocType, OrmMethods, Reactivity>>;\r\n    readonly $$: Reactified<Reactivity, RxDocument<RxDocType, OrmMethods, Reactivity>>;\r\n    readonly deleted$: Observable<boolean>;\r\n    readonly deleted$$: Reactified<Reactivity, boolean>;\r\n\r\n    readonly primary: string;\r\n    readonly allAttachments$: Observable<RxAttachment<RxDocType, OrmMethods, Reactivity>[]>;\r\n\r\n    // internal things\r\n    _data: RxDocumentData<RxDocType>;\r\n    primaryPath: string;\r\n    revision: string;\r\n    /**\r\n     * Used to de-duplicate the enriched property objects\r\n     * of the document. Lazily initialized on first property access.\r\n     */\r\n    _propertyCache: Map<string, any> | undefined;\r\n    $emit(cE: RxChangeEvent<RxDocType>): void;\r\n    _saveData(newData: any, oldData: RxDocumentData<RxDocType>): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;\r\n    // /internal things\r\n\r\n    // Returns the latest state of the document\r\n    getLatest(): RxDocument<RxDocType, OrmMethods, Reactivity>;\r\n\r\n\r\n    get$(path: string): Observable<any>;\r\n    get$$(path: string): Reactified<Reactivity, any>;\r\n    get(objPath: string): DeepReadonly<any>;\r\n    populate(objPath: string): Promise<RxDocument<RxDocType, OrmMethods, Reactivity> | any | null>;\r\n\r\n    /**\r\n     * mutate the document with a function\r\n     */\r\n    modify(mutationFunction: ModifyFunction<RxDocType>, context?: string): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;\r\n    incrementalModify(mutationFunction: ModifyFunction<RxDocType>, context?: string): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;\r\n\r\n    /**\r\n     * patches the given properties\r\n     */\r\n    patch(patch: Partial<RxDocType>): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;\r\n    incrementalPatch(patch: Partial<RxDocType>): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;\r\n\r\n    update(updateObj: UpdateQuery<RxDocType>): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;\r\n    incrementalUpdate(updateObj: UpdateQuery<RxDocType>): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;\r\n\r\n    updateCRDT(updateObj: CRDTEntry<RxDocType> | CRDTEntry<RxDocType>[]): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;\r\n\r\n    remove(): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;\r\n    incrementalRemove(): Promise<RxDocument<RxDocType, OrmMethods, Reactivity>>;\r\n\r\n    // only for temporary documents\r\n    set(objPath: string, value: any): RxDocument<RxDocType, OrmMethods, Reactivity>;\r\n    save(): Promise<boolean>;\r\n\r\n    // attachments\r\n    putAttachment(\r\n        creator: RxAttachmentCreator\r\n    ): Promise<RxAttachment<RxDocType, OrmMethods, Reactivity>>;\r\n    putAttachmentBase64(\r\n        creator: RxAttachmentCreatorBase64\r\n    ): Promise<RxAttachment<RxDocType, OrmMethods, Reactivity>>;\r\n    putAttachments(\r\n        creators: RxAttachmentCreator[]\r\n    ): Promise<RxAttachment<RxDocType, OrmMethods, Reactivity>[]>;\r\n    getAttachment(id: string): RxAttachment<RxDocType, OrmMethods, Reactivity> | null;\r\n    allAttachments(): RxAttachment<RxDocType, OrmMethods, Reactivity>[];\r\n\r\n    toJSON(withRevAndAttachments: true): DeepReadonly<RxDocumentData<RxDocType>>;\r\n    toJSON(withRevAndAttachments?: false): DeepReadonly<RxDocType>;\r\n\r\n    toMutableJSON(withRevAndAttachments: true): RxDocumentData<RxDocType>;\r\n    toMutableJSON(withRevAndAttachments?: false): RxDocType;\r\n\r\n    close(): void;\r\n}\r\n"],"mappings":"","ignoreList":[]}

package/dist/cjs/types/rx-error.d.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=rx-error.d.js.map

package/dist/cjs/types/rx-error.d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rx-error.d.js","names":[],"sources":["../../../src/types/rx-error.d.ts"],"sourcesContent":["import type { RxJsonSchema } from './rx-schema.d.ts';\r\nimport {\r\n    RxSchema\r\n} from '../rx-schema.ts';\r\nimport type { RxPlugin } from './rx-plugin.d.ts';\r\nimport { ERROR_MESSAGES } from '../plugins/dev-mode/error-messages.ts';\r\nimport type { RxReplicationWriteToMasterRow } from './replication-protocol.d.ts';\r\nimport type { BulkWriteRow, RxDocumentData } from './rx-storage.d.ts';\r\n\r\ntype KeyOf<T extends object> = Extract<keyof T, string>;\r\nexport type RxErrorKey = KeyOf<typeof ERROR_MESSAGES>;\r\n\r\nexport type {\r\n    RxError,\r\n    RxTypeError\r\n} from '../rx-error.ts';\r\n\r\n/**\r\n * this lists all possible parameters\r\n */\r\nexport interface RxErrorParameters {\r\n    readonly error?: PlainJsonError;\r\n    readonly errors?: PlainJsonError[];\r\n    readonly errorText?: string;\r\n    readonly writeError?: RxStorageWriteError<any>;\r\n    readonly schemaPath?: string;\r\n    readonly objPath?: string;\r\n    readonly rootPath?: string;\r\n    readonly childpath?: string;\r\n    readonly ids?: string[];\r\n    readonly obj?: any;\r\n    readonly document?: any;\r\n    readonly schema?: Readonly<RxJsonSchema<any> | RxSchema>;\r\n    readonly schemaObj?: any;\r\n    readonly pluginKey?: string;\r\n    readonly originalDoc?: Readonly<any>;\r\n    readonly finalDoc?: Readonly<any>;\r\n    readonly regex?: string;\r\n    readonly fieldName?: string;\r\n    readonly id?: string;\r\n    readonly documentId?: string;\r\n    readonly data?: any;\r\n    readonly missingCollections?: string[];\r\n    readonly primaryPath?: string;\r\n    readonly primary?: string;\r\n    readonly primaryKey?: string;\r\n    readonly have?: any;\r\n    readonly should?: any;\r\n    readonly name?: string;\r\n    readonly adapter?: any;\r\n    readonly link?: string;\r\n    readonly path?: string;\r\n    readonly value?: any;\r\n    readonly givenName?: string;\r\n    readonly fromVersion?: number;\r\n    readonly toVersion?: number;\r\n    readonly version?: number;\r\n    readonly args?: any;\r\n    readonly opts?: any;\r\n    readonly dataBefore?: any;\r\n    readonly dataAfter?: any;\r\n    readonly pull?: boolean;\r\n    readonly push?: boolean;\r\n    readonly url?: string;\r\n    readonly key?: string;\r\n    readonly queryObj?: any;\r\n    readonly query?: any;\r\n    readonly op?: string;\r\n    readonly skip?: any;\r\n    readonly limit?: any;\r\n    readonly passwordHash?: string;\r\n    readonly existingPasswordHash?: string;\r\n    readonly password?: string | any;\r\n    readonly minPassLength?: number;\r\n    readonly own?: any;\r\n    readonly source?: any;\r\n    readonly method?: any;\r\n    readonly field?: string;\r\n    readonly ref?: string;\r\n    readonly funName?: string;\r\n    readonly functionName?: string;\r\n    readonly schemaHash?: string;\r\n    readonly previousSchema?: Readonly<RxJsonSchema<any>>;\r\n    readonly previousSchemaHash?: string;\r\n    readonly type?: string;\r\n    readonly when?: string;\r\n    readonly parallel?: boolean;\r\n    readonly collection?: any;\r\n    readonly database?: any;\r\n    readonly storage?: string;\r\n    readonly indexes?: Array<string | string[]> | Readonly<Array<string | string[]>>;\r\n    readonly index?: string | string[] | readonly string[];\r\n    readonly plugin?: RxPlugin | any;\r\n    readonly plugins?: Set<RxPlugin | any>;\r\n\r\n    // used in the replication plugin\r\n\r\n    /**\r\n     * The checkpoint of the response from the last successful\r\n     * pull by the client.\r\n     * Null if there was no pull operation before\r\n     * so that there is no last pulled checkpoint.\r\n     */\r\n    readonly checkpoint?: any;\r\n    /**\r\n     * The documents that failed to be pushed.\r\n     * Typed as 'any' because they might be modified by the push modifier.\r\n     */\r\n    readonly pushRows?: RxReplicationWriteToMasterRow<any>[];\r\n    readonly direction?: 'pull' | 'push';\r\n\r\n    // google-drive-replication\r\n    readonly folderPath?: string;\r\n    readonly folderName?: string;\r\n    readonly file?: any;\r\n    readonly parentId?: string;\r\n\r\n    // fetch\r\n    readonly body?: any;\r\n    readonly status?: number;\r\n    readonly statusText?: string;\r\n    readonly headers?: Record<string, any>;\r\n    readonly code?: string;\r\n}\r\n\r\n/**\r\n * Error-Items which are created by the jsonschema-validator\r\n */\r\nexport type RxValidationError = {\r\n    readonly field: string;\r\n    readonly message: string;\r\n};\r\n\r\n/**\r\n * Use to have a transferable error object\r\n * in plain json instead of a JavaScript Error instance.\r\n */\r\nexport type PlainJsonError = {\r\n    name: string;\r\n    message: string;\r\n    rxdb?: true;\r\n    code?: RxErrorKey;\r\n    url?: string;\r\n    extensions?: Record<string, any>;\r\n    parameters?: RxErrorParameters;\r\n    stack?: string;\r\n};\r\n\r\n\r\n\r\n\r\n\r\n/**\r\n * Error that can happen per document when\r\n * RxStorage.bulkWrite() is called\r\n */\r\nexport type RxStorageWriteErrorBase<RxDocType> = {\r\n    status: number\r\n    | 409 // conflict\r\n    | 422 // schema validation error\r\n    | 510 // attachment data missing\r\n    ;\r\n\r\n    /**\r\n     * set this property to make it easy\r\n     * to detect if the object is a RxStorageBulkWriteError\r\n     */\r\n    isError: true;\r\n\r\n    // primary key of the document\r\n    documentId: string;\r\n\r\n    // the original document data that should have been written.\r\n    writeRow: BulkWriteRow<RxDocType>;\r\n\r\n    /**\r\n     * The context which was given to bulkWrite(),\r\n     * used for debugging.\r\n     */\r\n    context: string;\r\n};\r\n\r\nexport type RxStorageWriteErrorConflict<RxDocType> = RxStorageWriteErrorBase<RxDocType> & {\r\n    status: 409;\r\n    /**\r\n     * A conflict error state must contain the\r\n     * document state in the database.\r\n     * This ensures that we can continue resolving a conflict\r\n     * without having to pull the document out of the db first.\r\n     * Is not set if the error happens on an insert.\r\n     */\r\n    documentInDb: RxDocumentData<RxDocType>;\r\n};\r\n\r\nexport type RxStorageWriteErrorValidation<RxDocType> = RxStorageWriteErrorBase<RxDocType> & {\r\n    status: 422;\r\n    /**\r\n     * Other properties that give\r\n     * information about the error,\r\n     * for example a schema validation error\r\n     * might contain the exact error from the validator here.\r\n     * Must be plain JSON!\r\n     */\r\n    validationErrors: RxValidationError[];\r\n    /**\r\n     * For easier debugging,\r\n     * we directly put the schema into the error.\r\n     */\r\n    schema: RxJsonSchema<RxDocumentData<RxDocType>>;\r\n};\r\n\r\nexport type RxStorageWriteErrorAttachment<RxDocType> = RxStorageWriteErrorBase<RxDocType> & {\r\n    status: 510;\r\n    attachmentId: string;\r\n    documentInDb?: RxDocumentData<RxDocType>;\r\n};\r\n\r\n\r\nexport type RxStorageWriteError<RxDocType> =\r\n    RxStorageWriteErrorConflict<RxDocType> |\r\n    RxStorageWriteErrorValidation<RxDocType> |\r\n    RxStorageWriteErrorAttachment<RxDocType>;\r\n"],"mappings":"","ignoreList":[]}

package/dist/cjs/types/rx-plugin.d.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=rx-plugin.d.js.map

package/dist/cjs/types/rx-plugin.d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rx-plugin.d.js","names":[],"sources":["../../../src/types/rx-plugin.d.ts"],"sourcesContent":["import type {\r\n    RxQuery,\r\n    RxQueryOP,\r\n    MangoQuery\r\n} from './rx-query.d.ts';\r\nimport type {\r\n    RxCollection,\r\n    RxCollectionCreator\r\n} from './rx-collection.d.ts';\r\nimport type {\r\n    RxStorageInstanceCreationParams\r\n} from './rx-storage.d.ts';\r\nimport type {\r\n    DeepReadonly,\r\n    FilledMangoQuery,\r\n    RxDatabase,\r\n    RxDatabaseCreator,\r\n    RxDocument,\r\n    RxStorage,\r\n    RxReplicationWriteToMasterRow,\r\n    WithDeleted,\r\n    RxState,\r\n    BulkWriteRow,\r\n    RxStorageInstance\r\n} from './index.d.ts';\r\nimport type { RxSchema } from '../rx-schema.d.ts';\r\n\r\nexport type RxPluginPrePrepareRxQueryArgs = {\r\n    op: RxQueryOP;\r\n    queryObj: MangoQuery | string | number | Array<any>;\r\n    collection: RxCollection;\r\n};\r\n\r\nexport type RxPluginPreCreateRxQueryArgs = {\r\n    op: RxQueryOP;\r\n    queryObj: MangoQuery;\r\n    collection: RxCollection;\r\n};\r\n\r\nexport type RxPluginPreAddRxPluginArgs = {\r\n    // the plugin that is getting added\r\n    plugin: RxPlugin | any;\r\n    // previous added plugins\r\n    plugins: Set<RxPlugin | any>;\r\n};\r\n\r\nexport type RxPluginPrePrepareQueryArgs = {\r\n    rxQuery: RxQuery<any>;\r\n    mangoQuery: FilledMangoQuery<any>;\r\n};\r\n\r\n\r\n/**\r\n * Depending on which plugins are used together,\r\n * it is important that the plugin is able to define if\r\n * the hooks must be added as first or as last array item.\r\n * For example the encryption plugin must run encryption\r\n * before the key-compression changes the fieldnames.\r\n */\r\nexport type RxPluginHooks<Input> = {\r\n    /**\r\n     * Hook function that is added as first.\r\n     */\r\n    before?: (i: Input) => void;\r\n    /**\r\n     * Hook function that is added as last.\r\n     */\r\n    after?: (i: Input) => void;\r\n};\r\n\r\nexport interface RxPlugin {\r\n    /**\r\n     * A string to uniquely identifies the plugin.\r\n     * Can be used to throw when different versions of the same plugin are used.\r\n     * And also other checks.\r\n     * Use kebab-case.\r\n     */\r\n    readonly name: string;\r\n\r\n    /**\r\n     * set this to true so RxDB\r\n     * knows that this object in a rxdb plugin\r\n     */\r\n    readonly rxdb: true;\r\n\r\n    /**\r\n     * Init function where dependent plugins could be added.\r\n     * (optional)\r\n     */\r\n    init?(): any;\r\n\r\n    prototypes?: {\r\n        RxSchema?: (proto: RxSchema) => void;\r\n        RxDocument?: (proto: RxDocument) => void;\r\n        RxQuery?: (proto: RxQuery) => void;\r\n        RxCollection?: (proto: RxCollection) => void;\r\n        RxDatabase?: (proto: RxDatabase) => void;\r\n    };\r\n    overwritable?: {\r\n        isDevMode?: () => boolean;\r\n        deepFreezeWhenDevMode?: <T>(obj: T) => DeepReadonly<T>;\r\n        validatePassword?: Function;\r\n        checkAdapter?: Function;\r\n        tunnelErrorMessage?: Function;\r\n    };\r\n    hooks?: {\r\n        preAddRxPlugin?: RxPluginHooks<RxPluginPreAddRxPluginArgs>;\r\n        preCreateRxDatabase?: RxPluginHooks<any>;\r\n        createRxDatabase?: RxPluginHooks<{\r\n            database: RxDatabase;\r\n            creator: RxDatabaseCreator;\r\n        }>;\r\n        preCloseRxDatabase?: RxPluginHooks<RxDatabase>;\r\n        postRemoveRxDatabase?: RxPluginHooks<{\r\n            databaseName: string;\r\n            storage: RxStorage<any, any>;\r\n        }>;\r\n        createRxCollection?: RxPluginHooks<{\r\n            collection: RxCollection;\r\n            creator: RxCollectionCreator;\r\n        }>;\r\n        createRxState?: RxPluginHooks<{\r\n            collection: RxCollection;\r\n            state: RxState<unknown, unknown>;\r\n        }>;\r\n        preCreateRxCollection?: RxPluginHooks<RxCollectionCreator<any> & {\r\n            name: string;\r\n            database: RxDatabase;\r\n        }>;\r\n        postCloseRxCollection?: RxPluginHooks<RxCollection>;\r\n        postRemoveRxCollection?: RxPluginHooks<{\r\n            storage: RxStorage<any, any>;\r\n            databaseName: string;\r\n            collectionName: string;\r\n        }>;\r\n        preCreateRxSchema?: RxPluginHooks<any>;\r\n        createRxSchema?: RxPluginHooks<any>;\r\n        prePrepareRxQuery?: RxPluginHooks<RxPluginPrePrepareRxQueryArgs>;\r\n        preCreateRxQuery?: RxPluginHooks<RxPluginPreCreateRxQueryArgs>;\r\n        prePrepareQuery?: RxPluginHooks<RxPluginPrePrepareQueryArgs>;\r\n        createRxQuery?: RxPluginHooks<RxQuery>;\r\n        createRxDocument?: RxPluginHooks<any>;\r\n        postCreateRxDocument?: RxPluginHooks<any>;\r\n        preCreateRxStorageInstance?: RxPluginHooks<RxStorageInstanceCreationParams<any, any>>;\r\n        /**\r\n         * Runs before a write to the storage instance of a RxCollection or RxDatabase.\r\n         */\r\n        preStorageWrite?: RxPluginHooks<{\r\n            storageInstance: RxStorageInstance<any, any, any, any>;\r\n            rows: BulkWriteRow<any>[];\r\n        }>;\r\n        preMigrateDocument?: RxPluginHooks<any>;\r\n        postMigrateDocument?: RxPluginHooks<any>;\r\n        postCleanup?: RxPluginHooks<{\r\n            databaseName: string;\r\n            collectionName: string;\r\n        }>;\r\n        preReplicationMasterWrite?: RxPluginHooks<{\r\n            rows: RxReplicationWriteToMasterRow<any>[];\r\n            collection: RxCollection;\r\n        }>;\r\n        preReplicationMasterWriteDocumentsHandle?: RxPluginHooks<{\r\n            result: WithDeleted<any>[];\r\n            collection: RxCollection;\r\n        }>;\r\n    };\r\n}\r\n"],"mappings":"","ignoreList":[]}

package/dist/cjs/types/rx-query.d.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=rx-query.d.js.map

package/dist/cjs/types/rx-query.d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rx-query.d.js","names":[],"sources":["../../../src/types/rx-query.d.ts"],"sourcesContent":["import type {\r\n    RxQueryBase\r\n} from '../rx-query.d.ts';\r\nimport type { Paths, StringKeys } from './util.d.ts';\r\n\r\n/**\r\n * Typed Mango Query Selector\r\n * @link https://github.com/mongodb/node-mongodb-native/blob/26bce4a8debb65df5a42dc8599e886c9c83de10d/src/mongo_types.ts\r\n * @link https://stackoverflow.com/a/58436959/3443137\r\n */\r\n\r\n\r\nexport type PropertyType<Type, Property extends string> = string extends Property\r\n    ? unknown\r\n    : Property extends keyof Type\r\n    ? Type[Property]\r\n    : Property extends `${number}`\r\n    ? Type extends ReadonlyArray<infer ArrayType>\r\n    ? ArrayType\r\n    : unknown\r\n    : Property extends `${infer Key}.${infer Rest}`\r\n    ? Key extends `${number}`\r\n    ? Type extends ReadonlyArray<infer ArrayType>\r\n    ? PropertyType<ArrayType, Rest>\r\n    : unknown\r\n    : Key extends keyof Type\r\n    ? Type[Key] extends Map<string, infer MapType>\r\n    ? MapType\r\n    : PropertyType<Type[Key], Rest>\r\n    : unknown\r\n    : unknown;\r\n\r\n\r\nexport type MangoQueryRegexOptions = 'i' | 'g' | 'm' | 'gi' | 'ig' | 'igm' | string;\r\n\r\n/*\r\n * The MongoDB query library is huge and we do not need all the operators.\r\n * If you add an operator here, make sure that you properly add a test in\r\n * the file /test/unit/rx-storage-query-correctness.test.ts\r\n *\r\n * @link https://github.com/kofrasa/mingo#es6\r\n */\r\nexport interface MangoQueryOperators<PathValueType> {\r\n    $eq?: PathValueType;\r\n    $gt?: PathValueType;\r\n    $gte?: PathValueType;\r\n    $lt?: PathValueType;\r\n    $lte?: PathValueType;\r\n    $ne?: PathValueType;\r\n    $in?: PathValueType[];\r\n    $nin?: PathValueType[];\r\n    $regex?: string;\r\n    $options?: MangoQueryRegexOptions;\r\n    $exists?: boolean;\r\n    $type?: 'null' | 'boolean' | 'number' | 'string' | 'array' | 'object';\r\n    $mod?: [number, number];\r\n    $not?: PathValueType;\r\n    $size?: number;\r\n    $elemMatch?: MangoQuerySelector<PathValueType>;\r\n}\r\n\r\nexport type MangoQuerySelector<DocType> = Partial<{\r\n    [Property in Paths<DocType>]: MangoQueryOperators<any> | PropertyType<DocType, Property>;\r\n}> & {\r\n    $and?: MangoQuerySelector<DocType>[];\r\n    $or?: MangoQuerySelector<DocType>[];\r\n    $nor?: MangoQuerySelector<DocType>[];\r\n};\r\n\r\n/**\r\n * Discussion was at:\r\n * @link https://github.com/pubkey/rxdb/issues/1972\r\n */\r\nexport type MangoQuerySortDirection = 'asc' | 'desc';\r\nexport type MangoQuerySortPart<RxDocType = any> = {\r\n    [k in StringKeys<RxDocType> | string]: MangoQuerySortDirection;\r\n};\r\n\r\nexport type MangoQuerySelectorAndIndex<RxDocType = any> = {\r\n    /**\r\n     * Selector is optional,\r\n     * if not given, the query matches all documents\r\n     * that are not _deleted=true.\r\n     */\r\n    selector?: MangoQuerySelector<RxDocType>;\r\n    /**\r\n     * By default, the RxStorage implementation\r\n     * decides which index to use when running the query.\r\n     *\r\n     * For better performance, a different index might be defined\r\n     * by setting it in the query.\r\n     * How this improves performance and if the defined index is used,\r\n     * depends on the RxStorage implementation.\r\n     */\r\n    index?: string | string[];\r\n};\r\n\r\nexport type MangoQueryNoLimit<RxDocType> = MangoQuerySelectorAndIndex<RxDocType> & {\r\n    /**\r\n     * Sorting of the results.\r\n     * If no sort is set, RxDB will sort by the primary key.\r\n     * Also if sort is set, RxDB will add primaryKey sorting\r\n     * if the primaryKey was not in the sort parameters before.\r\n     * This ensures that there is a deterministic sorting of the\r\n     * results, not mather at which order the documents have been\r\n     * inserted into the storage.\r\n     */\r\n    sort?: MangoQuerySortPart<RxDocType>[];\r\n};\r\n\r\nexport type MangoQuery<RxDocType = any> = MangoQueryNoLimit<RxDocType> & {\r\n    skip?: number;\r\n    limit?: number;\r\n};\r\n\r\nexport type RxQueryOP = 'find' | 'findOne' | 'count' | 'findByIds';\r\n\r\nexport declare class RxQuery<\r\n    RxDocumentType = any,\r\n    RxQueryResult = any,\r\n    OrmMethods = {},\r\n    Reactivity = unknown\r\n> extends RxQueryBase<RxDocumentType, RxQueryResult, OrmMethods, Reactivity> {\r\n    equals(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;\r\n    eq(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;\r\n    or(queryObj: keyof RxDocumentType | string | any[]): RxQuery<RxDocumentType, RxQueryResult>;\r\n    nor(queryObj: keyof RxDocumentType | string | any[]): RxQuery<RxDocumentType, RxQueryResult>;\r\n    and(queryObj: keyof RxDocumentType | string | any[]): RxQuery<RxDocumentType, RxQueryResult>;\r\n    gt(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;\r\n    gte(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;\r\n    lt(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;\r\n    lte(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;\r\n    ne(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;\r\n    in(queryObj: any[]): RxQuery<RxDocumentType, RxQueryResult>;\r\n    nin(queryObj: any[]): RxQuery<RxDocumentType, RxQueryResult>;\r\n    all(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;\r\n    regex(queryObj: string | {\r\n        $regex: string;\r\n        $options: MangoQueryRegexOptions;\r\n    }): RxQuery<RxDocumentType, RxQueryResult>;\r\n    exists(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;\r\n    elemMatch(queryObj: any): RxQuery<RxDocumentType, RxQueryResult>;\r\n    mod(p1: any, p2: any, p3: any): RxQuery<RxDocumentType, RxQueryResult>;\r\n}\r\n"],"mappings":"","ignoreList":[]}

package/dist/cjs/types/rx-schema.d.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=rx-schema.d.js.map

package/dist/cjs/types/rx-schema.d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rx-schema.d.js","names":[],"sources":["../../../src/types/rx-schema.d.ts"],"sourcesContent":["import { AsTyped } from 'as-typed';\r\nimport type { CRDTSchemaOptions } from './plugins/crdt.d.ts';\r\nimport type { StringKeys } from './util.d.ts';\r\n\r\n/**\r\n * @link https://github.com/types/lib-json-schema/blob/master/v4/index.d.ts\r\n */\r\nexport type JsonSchemaTypes = 'array' | 'boolean' | 'integer' | 'number' | 'null' | 'object' | 'string' | (string & {});\r\n\r\nexport type CompositePrimaryKey<RxDocType> = {\r\n    /**\r\n     * The top level field of the document that will be used\r\n     * to store the composite key as string.\r\n     */\r\n    key: StringKeys<RxDocType>;\r\n\r\n    /**\r\n     * The fields of the composite key,\r\n     * the fields must be required and final\r\n     * and have the type number, int, or string.\r\n     */\r\n    fields: (StringKeys<RxDocType> | string)[] | readonly (StringKeys<RxDocType> | string)[];\r\n    /**\r\n     * The separator which is used to concat the\r\n     * primary fields values.\r\n     * Choose a character as separator that is known\r\n     * to never appear inside of the primary fields values.\r\n     * I recommend to use the pipe char '|'.\r\n     */\r\n    separator: string;\r\n};\r\n\r\nexport type PrimaryKey<RxDocType> = StringKeys<RxDocType> | CompositePrimaryKey<RxDocType>;\r\n\r\nexport type JsonSchema<RxDocType = any> = {\r\n    allOf?: JsonSchema[] | readonly JsonSchema[];\r\n    anyOf?: JsonSchema[] | readonly JsonSchema[];\r\n    oneOf?: JsonSchema[] | readonly JsonSchema[];\r\n    additionalItems?: boolean | JsonSchema;\r\n    additionalProperties?: boolean | JsonSchema;\r\n    type?: JsonSchemaTypes | JsonSchemaTypes[] | readonly JsonSchemaTypes[];\r\n    description?: string;\r\n    dependencies?: {\r\n        [key: string]: JsonSchema | string[] | readonly string[];\r\n    };\r\n    exclusiveMinimum?: number;\r\n    exclusiveMaximum?: number;\r\n    items?: JsonSchema | JsonSchema[] | readonly JsonSchema[];\r\n    multipleOf?: number;\r\n    maxProperties?: number;\r\n    maximum?: number;\r\n    minimum?: number;\r\n    maxLength?: number;\r\n    minLength?: number;\r\n    maxItems?: number;\r\n    minItems?: number;\r\n    minProperties?: number;\r\n    pattern?: string;\r\n    patternProperties?: {\r\n        [key: string]: JsonSchema;\r\n    };\r\n    properties?: {\r\n        [key in StringKeys<RxDocType>]: JsonSchema;\r\n    };\r\n    required?: string[] | readonly string[];\r\n    uniqueItems?: boolean;\r\n    enum?: any[] | readonly any[];\r\n    not?: JsonSchema;\r\n    definitions?: {\r\n        [key: string]: JsonSchema;\r\n    };\r\n    format?: 'date-time' | 'email' | 'hostname' | 'ipv4' | 'ipv6' | 'uri' | string;\r\n    example?: any;\r\n\r\n    // RxDB-specific\r\n    ref?: string;\r\n    final?: boolean;\r\n};\r\n\r\nexport interface TopLevelProperty extends JsonSchema {\r\n    default?: any;\r\n}\r\n\r\n/**\r\n * @link https://developer.mozilla.org/en-US/docs/Web/API/Compression_Streams_API\r\n */\r\nexport type CompressionMode = 'deflate' | 'gzip';\r\n\r\nexport type RxJsonSchema<\r\n    /**\r\n     * The doctype must be given, and '=any' cannot be used,\r\n     * otherwise the keyof of primaryKey\r\n     * would be optional when the type of the document is not known.\r\n     */\r\n    RxDocType\r\n> = {\r\n    title?: string;\r\n    description?: string;\r\n    version: number;\r\n\r\n    /**\r\n     * The primary key of the documents.\r\n     * Must be in the top level of the properties of the schema\r\n     * and that property must have the type 'string'\r\n     */\r\n    primaryKey: PrimaryKey<RxDocType>;\r\n\r\n    /**\r\n     * TODO this looks like a typescript-bug\r\n     * we have to allows all string because the 'object'-literal is not recognized\r\n     * retry this in later typescript-versions\r\n     */\r\n    type: 'object' | string;\r\n\r\n    properties: { [key in StringKeys<RxDocType>]: TopLevelProperty };\r\n\r\n    /**\r\n     * On the top level the required-array must be set\r\n     * because we always have to set the primary key to required.\r\n     */\r\n    required?: StringKeys<RxDocType>[] | readonly StringKeys<RxDocType>[];\r\n\r\n    /**\r\n     * Indexes that will be used for the queries.\r\n     * RxDB will internally prepend the _deleted field to the index\r\n     * because queries do NOT return documents with _deleted=true.\r\n     * @example ['firstName', ['lastName', 'yearOfBirth']]\r\n     */\r\n    indexes?: (string | string[])[] | (string | readonly string[])[] | readonly (string | string[])[] | readonly (string | readonly string[])[];\r\n\r\n    /**\r\n     * Internally used indexes that do not get _deleted prepended\r\n     * by RxDB. Use these to speed up queries that are run manually on the storage\r\n     * or to speed up requests when you use the RxDB server.\r\n     * These could also be utilised when you build a plugin that\r\n     * has to query documents without respecting the _deleted value.\r\n     * @example [['firstName'], ['lastName', 'yearOfBirth']]\r\n     */\r\n    internalIndexes?: string[][] | readonly string[][];\r\n\r\n\r\n    /**\r\n     * Array of fields that should be encrypted.\r\n     * @link https://rxdb.info/encryption.html\r\n     * @example ['secret']\r\n     */\r\n    encrypted?: string[] | readonly string[];\r\n\r\n    /**\r\n     * Enables key compression for the collection to reduce storage size.\r\n     * @link https://rxdb.info/key-compression.html\r\n     * @example true\r\n     */\r\n    keyCompression?: boolean;\r\n\r\n    /**\r\n     * if not set, rxdb will set 'false' as default\r\n     * Having additionalProperties: true is not allowed on the root level to ensure\r\n     * that property names do not clash with properties of the RxDocument class\r\n     * or ORM methods.\r\n     */\r\n    additionalProperties?: false;\r\n    attachments?: {\r\n        encrypted?: boolean;\r\n        /**\r\n         * @link https://developer.mozilla.org/en-US/docs/Web/API/Compression_Streams_API\r\n         */\r\n        compression?: CompressionMode;\r\n        /**\r\n         * Optional whitelist of MIME type patterns that should be compressed.\r\n         * Supports '*' suffix for prefix matching (e.g., 'text/*').\r\n         * If omitted, a built-in default list of compressible types is used.\r\n         * Only relevant when 'compression' is set.\r\n         */\r\n        compressibleTypes?: string[];\r\n    };\r\n    /**\r\n     * Options for the sharding plugin of rxdb-premium.\r\n     * We set these on the schema because changing the shard amount or mode\r\n     * will require a migration.\r\n     * @link https://rxdb.info/rx-storage-sharding.html\r\n     */\r\n    sharding?: {\r\n        /**\r\n         * Amount of shards.\r\n         * This value cannot be changed after you have stored data,\r\n         * if you change it anyway, you will loose the existing data.\r\n         */\r\n        shards: number;\r\n        /**\r\n         * Either shard by collection or by database.\r\n         * For most use cases (IndexedDB based storages), sharding by collection is the way to go\r\n         * because it has a faster initial load time.\r\n         */\r\n        mode: 'database' | 'collection';\r\n    };\r\n    /**\r\n     * Configuration for Conflict-free Replicated Data Types (CRDTs).\r\n     * @link https://rxdb.info/crdt.html\r\n     * @example { field: 'crdts' }\r\n     */\r\n    crdt?: CRDTSchemaOptions<RxDocType>;\r\n};\r\n\r\n/**\r\n * Used to aggregate the document type from the schema.\r\n * @link https://github.com/pubkey/rxdb/discussions/3467\r\n */\r\nexport type ExtractDocumentTypeFromTypedRxJsonSchema<TypedRxJsonSchema> = AsTyped<TypedRxJsonSchema>;\r\n"],"mappings":"","ignoreList":[]}

package/dist/cjs/types/rx-storage.d.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=rx-storage.d.js.map

package/dist/cjs/types/rx-storage.d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rx-storage.d.js","names":[],"sources":["../../../src/types/rx-storage.d.ts"],"sourcesContent":["import type { ChangeEvent } from 'event-reduce-js';\r\nimport type { RxChangeEvent } from './rx-change-event.d.ts';\r\nimport type { RxDocumentMeta } from './rx-document.d.ts';\r\nimport type { RxStorageWriteError } from './rx-error.d.ts';\r\nimport type { RxJsonSchema } from './rx-schema.d.ts';\r\nimport type { Override } from './util.d.ts';\r\n\r\n/**\r\n * The document data how it comes out of the storage instance.\r\n * Contains all meta data like revision, attachments and deleted-flag.\r\n */\r\nexport type RxDocumentData<T> = T & {\r\n\r\n    /**\r\n     * As other NoSQL databases,\r\n     * RxDB also assumes that no data is finally deleted.\r\n     * Instead the documents are stored with _deleted: true\r\n     * which means they will not be returned at queries.\r\n     */\r\n    _deleted: boolean;\r\n\r\n    /**\r\n     * The attachments meta data is stored besides to document.\r\n     */\r\n    _attachments: {\r\n        [attachmentId: string]: RxAttachmentData;\r\n    };\r\n\r\n    /**\r\n     * Contains a revision which is concatenated with a [height: number]-[identifier: string]\r\n     * like: '1-3hl4kj3l4kgj34g34glk'.\r\n     * The revision is used to detect write conflicts and have a document history.\r\n     * Revisions behave similar to couchdb revisions:\r\n     * @link https://docs.couchdb.org/en/stable/replication/conflicts.html#revision-tree\r\n\r\n    * When writing a document, you must send the correct revision in the previous-field\r\n     * to make sure that you do not cause a write conflict.\r\n     * The revision of the 'new' document-field must be created, for example via util.createRevision().\r\n     * Any revision that matches the [height]-[hash] format can be used.\r\n     */\r\n    _rev: string;\r\n    _meta: RxDocumentMeta;\r\n};\r\n\r\nexport type RxDocumentDataById<RxDocType> = {\r\n    [documentId: string]: RxDocumentData<RxDocType>;\r\n};\r\n\r\n/**\r\n * The document data how it is send to the\r\n * storage instance to save it.\r\n */\r\n// We & T here instead of in RxDocumentData to preserver indexability by keyof T which the Override breaks\r\nexport type RxDocumentWriteData<T> = T & Override<RxDocumentData<{}>, {\r\n    _attachments: {\r\n        /**\r\n         * To create a new attachment, set the write data\r\n         * To delete an attachment, leave it out on the _attachments property.\r\n         * To change an attachment, set the new write data.\r\n         * To not touch an attachment, just send the stub again\r\n         * which came out of the storage instance.\r\n         */\r\n        [attachmentId: string]: RxAttachmentData | RxAttachmentWriteData;\r\n    };\r\n}>;\r\n\r\nexport type WithDeleted<DocType> = DocType & {\r\n    _deleted: boolean;\r\n};\r\nexport type WithDeletedAndAttachments<DocType> = DocType & {\r\n    _deleted: boolean;\r\n\r\n    /**\r\n     * Here the _attachments might exist\r\n     * or might not, depending one the use case.\r\n     */\r\n    _attachments?: {\r\n        [attachmentId: string]: RxAttachmentData | RxAttachmentWriteData;\r\n    };\r\n};\r\n\r\n/**\r\n * Send to the bulkWrite() method of a storage instance.\r\n */\r\nexport type BulkWriteRow<RxDocType> = {\r\n    /**\r\n     * The current document state in the storage engine,\r\n     * assumed by the application.\r\n     * Undefined if the document is a new insert.\r\n     * Notice that we send the full document data as 'previous', not just the revision.\r\n     * The reason is that to get the previous revision you anyway have to get the full\r\n     * previous document and so it is easier to just send it all to the storage instance.\r\n     * This will later allow us to use something different then the _rev key for conflict detection\r\n     * when we implement other storage instances.\r\n     */\r\n    previous?: RxDocumentData<RxDocType>;\r\n    /**\r\n     * The new document data to be stored in the storage instance.\r\n     */\r\n    document: RxDocumentWriteData<RxDocType>;\r\n};\r\nexport type BulkWriteRowById<RxDocType> = {\r\n    [documentId: string]: BulkWriteRow<RxDocType>;\r\n};\r\n\r\n/**\r\n * After the RxStorage has processed all rows,\r\n * we have this to work with afterwards.\r\n */\r\nexport type BulkWriteRowProcessed<RxDocType> = BulkWriteRow<RxDocType> & {\r\n    document: RxDocumentData<RxDocType>;\r\n};\r\n\r\n\r\nexport type RxAttachmentData = {\r\n    /**\r\n     * Size of the attachments data\r\n     */\r\n    length: number;\r\n    /**\r\n     * Content type like 'plain/text'\r\n     */\r\n    type: string;\r\n    /**\r\n     * The hash of the attachments content.\r\n     * It is calculated by RxDB, and send to the storage.\r\n     * The only guarantee is that the digest will change when the attachments data changes.\r\n     * @link https://github.com/pouchdb/pouchdb/issues/3156#issuecomment-66831010\r\n     * @link https://github.com/pubkey/rxdb/pull/4107\r\n     */\r\n    digest: string;\r\n};\r\n\r\n/**\r\n * Data which is needed for new attachments\r\n * that are send from RxDB to the RxStorage implementation.\r\n */\r\nexport type RxAttachmentWriteData = RxAttachmentData & {\r\n    /**\r\n     * The data of the attachment as a Blob.\r\n     * Blob is the canonical internal type because:\r\n     * - Attachments are blob-like things (images, videos, PDFs)\r\n     * - Blob is immutable (safe, no accidental mutation)\r\n     * - Blob.type carries MIME type metadata\r\n     * - Blob.size gives length synchronously\r\n     * - Blob is structured-cloneable (works with Worker/Electron postMessage)\r\n     * - IndexedDB stores Blobs efficiently (some engines use external blob storage)\r\n     *\r\n     * Conversion to ArrayBuffer only happens at boundaries that require it:\r\n     * encryption (Web Crypto), compression (CompressionStream), digest hashing,\r\n     * and WebSocket serialization.\r\n     *\r\n     * Encryption/compression run in the wrapRxStorageInstance layer OUTSIDE\r\n     * storage transactions, so Blob does not extend transaction lifetimes.\r\n     */\r\n    data: Blob;\r\n};\r\n\r\n\r\n/**\r\n * The returned data from RxStorageInstance.bulkWrite()\r\n * For better performance, we do NOT use an indexed object,\r\n * but only plain arrays. Because most of the time\r\n * RxDB anyway only need the array data and we can save performance\r\n * by not indexing the results.\r\n *\r\n * We do not longer return the written documents. We only return the errors.\r\n * This is because we construct the written docs array from the input+errors anyway\r\n * and transferring large amounts of data has bad performance when the storage\r\n * is running in a different realm like a WebWorker or remote.\r\n */\r\nexport type RxStorageBulkWriteResponse<RxDocType> = {\r\n    /**\r\n     * contains all errored writes.\r\n     */\r\n    error: RxStorageWriteError<RxDocType>[];\r\n};\r\n\r\n/**\r\n * We return a complex object instead of a single array\r\n * so we are able to add additional fields in the future.\r\n */\r\nexport type RxStorageQueryResult<RxDocType> = {\r\n    // the found documents, sort order is important.\r\n    documents: RxDocumentData<RxDocType>[];\r\n};\r\n\r\nexport type RxStorageCountResult = {\r\n    count: number;\r\n    /**\r\n     * Returns the mode which was used by the storage\r\n     * to count the documents.\r\n     * If this returns 'slow', RxDB will throw by default\r\n     * if 'allowSlowCount' is not set.\r\n     */\r\n    mode: 'fast' | 'slow';\r\n};\r\n\r\nexport type RxStorageInstanceCreationParams<RxDocType, InstanceCreationOptions> = {\r\n\r\n    /**\r\n     * A string to uniquely identify the instance of the JavaScript object\r\n     * of the RxDatabase where this RxStorageInstance belongs to.\r\n     * In most cases you would use RxDatabase.token here.\r\n     *\r\n     * This is used so that we can add caching or reuse stuff that belongs to the same RxDatabase.\r\n     * For example the BroadcastChannel that is used for event propagation between multiple browser tabs\r\n     * is cached by this token.\r\n     *\r\n     * In theory we could just use the databaseName for that. But to make it easier in unit tests\r\n     * to simulate cross-tab usage, we cannot assume that the databaseName is unique in a single\r\n     * JavaScript process. Therefore we use the instance token instead.\r\n     */\r\n    databaseInstanceToken: string;\r\n\r\n\r\n    databaseName: string;\r\n    collectionName: string;\r\n    schema: RxJsonSchema<RxDocumentData<RxDocType>>;\r\n    options: InstanceCreationOptions;\r\n    /**\r\n     * If multiInstance is true, there can be more\r\n     * then one instance of the database, for example\r\n     * when multiple browser tabs exist or more then one Node.js\r\n     * process relies on the same storage.\r\n     */\r\n    multiInstance: boolean;\r\n    /**\r\n     * Typed as `any` because different encryption plugins\r\n     * may use passwords that are not strings.\r\n     */\r\n    password?: string | any;\r\n\r\n    /**\r\n     * Some storages can do additional checks\r\n     * that are performance expensive\r\n     * and should only be done in dev-mode.\r\n     */\r\n    devMode: boolean;\r\n};\r\n\r\nexport type ChangeStreamOptions = {\r\n\r\n    /**\r\n     * Sequence number of the first event to start with.\r\n     * If you want to get all ongoing events,\r\n     * first get the latest sequence number and input it here.\r\n     *\r\n     * Optional on changeStream,\r\n     * will start from the newest sequence.\r\n     */\r\n    startSequence?: number;\r\n    /**\r\n     * limits the amount of results\r\n     */\r\n    limit?: number;\r\n};\r\n\r\n/**\r\n * In the past we handles each RxChangeEvent by its own.\r\n * But it has been shown that this take way more performance then needed,\r\n * especially when the events get transferred over a data layer\r\n * like with WebWorkers or the BroadcastChannel.\r\n * So we now process events as bulks internally.\r\n */\r\nexport type EventBulk<EventType, CheckpointType> = {\r\n    /**\r\n     * Unique id of the bulk,\r\n     * used to detect duplicate bulks\r\n     * that have already been processed.\r\n     */\r\n    id: string;\r\n    events: EventType[];\r\n\r\n    /**\r\n     * Required for replication.\r\n     * Passing this checkpoint into getChangedDocumentsSince()\r\n     * must return all items that have been modified AFTER this write event.\r\n     */\r\n    checkpoint: CheckpointType;\r\n\r\n    /**\r\n     * The context that was given at the call to bulkWrite()\r\n     * that caused this EventBulk.\r\n     */\r\n    context: string;\r\n};\r\n\r\nexport type ChangeStreamEvent<DocType> = ChangeEvent<RxDocumentData<DocType>> & {\r\n    /**\r\n     * An integer that is increasing\r\n     * and unique per event.\r\n     * Can be used to sort events or get information\r\n     * about how many events there are.\r\n     */\r\n    sequence: number;\r\n    /**\r\n     * The value of the primary key\r\n     * of the changed document\r\n     */\r\n    id: string;\r\n};\r\n\r\nexport type RxStorageChangeEvent<RxDocType> = Omit<RxChangeEvent<RxDocType>, 'isLocal' | 'collectionName'>;\r\n\r\n/**\r\n * An example for how a RxStorage checkpoint can look like.\r\n * NOTICE: Not all implementations use this type.\r\n */\r\nexport type RxStorageDefaultCheckpoint = {\r\n    id: string;\r\n    lwt: number;\r\n};\r\n\r\n\r\n\r\n\r\nexport type CategorizeBulkWriteRowsOutput<RxDocType> = {\r\n    bulkInsertDocs: BulkWriteRowProcessed<RxDocType>[];\r\n    bulkUpdateDocs: BulkWriteRowProcessed<RxDocType>[];\r\n\r\n    errors: RxStorageWriteError<RxDocType>[];\r\n    eventBulk: EventBulk<RxStorageChangeEvent<RxDocumentData<RxDocType>>, any>;\r\n    attachmentsAdd: {\r\n        documentId: string;\r\n        attachmentId: string;\r\n        attachmentData: RxAttachmentWriteData;\r\n        digest: string;\r\n    }[];\r\n    attachmentsRemove: {\r\n        documentId: string;\r\n        attachmentId: string;\r\n        digest: string;\r\n    }[];\r\n    attachmentsUpdate: {\r\n        documentId: string;\r\n        attachmentId: string;\r\n        attachmentData: RxAttachmentWriteData;\r\n        digest: string;\r\n    }[];\r\n    /**\r\n     * Contains the non-error document row that\r\n     * has the newest _meta.lwt time.\r\n     * Empty if no successful write exists.\r\n     */\r\n    newestRow?: BulkWriteRowProcessed<RxDocType>;\r\n};\r\n"],"mappings":"","ignoreList":[]}

package/dist/cjs/types/rx-storage.interface.d.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=rx-storage.interface.d.js.map

package/dist/cjs/types/rx-storage.interface.d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rx-storage.interface.d.js","names":[],"sources":["../../../src/types/rx-storage.interface.d.ts"],"sourcesContent":["import type {\r\n    BulkWriteRow,\r\n    EventBulk,\r\n    RxDocumentData,\r\n    RxStorageBulkWriteResponse,\r\n    RxStorageChangeEvent,\r\n    RxStorageCountResult,\r\n    RxStorageInstanceCreationParams,\r\n    RxStorageQueryResult\r\n} from './rx-storage.ts';\r\nimport type {\r\n    MangoQuerySelector,\r\n    MangoQuerySortPart,\r\n    RxJsonSchema,\r\n    RxQueryPlan\r\n} from './index.d.ts';\r\nimport type {\r\n    Observable\r\n} from 'rxjs';\r\n\r\n/**\r\n * RxStorage\r\n * This is an interface that abstracts the storage engine.\r\n * This allows us to use RxDB with different storage engines.\r\n *\r\n * @link https://rxdb.info/rx-storage.html\r\n * @link https://github.com/pubkey/rxdb/issues/1636\r\n */\r\n\r\n/**\r\n * A RxStorage is a module that acts\r\n * as a factory that can create multiple RxStorageInstance\r\n * objects.\r\n *\r\n * All data inputs and outputs of a StorageInstance must be structured-cloneable.\r\n * Document data must be plain JSON objects. Attachment data uses Blob.\r\n * Do not use Map, Set or anything else that is not structured-cloneable.\r\n * This will ensure that the storage can exchange data\r\n * when it is a WebWorker or a WASM process or data is send via BroadcastChannel.\r\n * The only exception is the WebSocket transport, which serializes at its boundary.\r\n */\r\nexport interface RxStorage<Internals, InstanceCreationOptions> {\r\n    /**\r\n     * name of the storage engine\r\n     * used to detect if plugins do not work so we can throw proper errors.\r\n     */\r\n    readonly name: string;\r\n\r\n    /**\r\n     * RxDB version is part of the storage\r\n     * so we can have fallbacks and stuff when\r\n     * multiple storages with different version are in use\r\n     * like in the storage migration plugin.\r\n     */\r\n    readonly rxdbVersion: string;\r\n\r\n    /**\r\n     * Creates a storage instance\r\n     * that can contain the NoSQL documents of a collection.\r\n     */\r\n    createStorageInstance<RxDocType>(\r\n        params: RxStorageInstanceCreationParams<RxDocType, InstanceCreationOptions>\r\n    ): Promise<RxStorageInstance<RxDocType, Internals, InstanceCreationOptions>>;\r\n}\r\n\r\n\r\n/**\r\n * User provided mango queries will be filled up by RxDB via normalizeMangoQuery()\r\n * so we do not have to do many if-field-exist tests in the internals.\r\n */\r\nexport type FilledMangoQuery<RxDocType> = {\r\n    /**\r\n     * The selector is required here.\r\n     */\r\n    selector: MangoQuerySelector<RxDocumentData<RxDocType>>;\r\n\r\n    /**\r\n     * In contrast to the user-provided MangoQuery,\r\n     * the sorting is required here because\r\n     * RxDB has to ensure that the primary key is always\r\n     * part of the sort params.\r\n     */\r\n    sort: MangoQuerySortPart<RxDocumentData<RxDocType>>[];\r\n\r\n    /**\r\n     * In the normalized mango query,\r\n     * the index must always be a string[],\r\n     * never just a string.\r\n     * This makes it easier to use the query because\r\n     * we do not have to do an array check.\r\n     */\r\n    index?: string[];\r\n\r\n    /**\r\n     * Skip must be set which defaults to 0\r\n     */\r\n    skip: number;\r\n\r\n    limit?: number;\r\n};\r\n\r\n\r\n/**\r\n * Before sending a query to the storageInstance.query()\r\n * we run it through the query planner and do some normalization\r\n * stuff. Notice that the queryPlan is a hint for the storage and\r\n * it is not required to use it when running queries. Some storages\r\n * might use their own query planning instead.\r\n */\r\nexport type PreparedQuery<RxDocType> = {\r\n    // original query from the input\r\n    query: FilledMangoQuery<RxDocType>;\r\n    queryPlan: RxQueryPlan;\r\n};\r\n\r\nexport interface RxStorageInstance<\r\n    /**\r\n     * The type of the documents that can be stored in this instance.\r\n     * All documents in an instance must comply to the same schema.\r\n     * Also all documents are RxDocumentData with the meta properties like\r\n     * _deleted or _rev etc.\r\n     */\r\n    RxDocType,\r\n    Internals,\r\n    InstanceCreationOptions,\r\n    CheckpointType = any\r\n> {\r\n    readonly databaseName: string;\r\n    /**\r\n     * Returns the internal data that is used by the storage engine.\r\n     */\r\n    readonly internals: Readonly<Internals>;\r\n    readonly options: Readonly<InstanceCreationOptions>;\r\n    /**\r\n     * The schema that defines the documents that are stored in this instance.\r\n     * Notice that the schema must be enhanced with the meta properties like\r\n     * _meta, _rev and _deleted etc. which are added by fillWithDefaultSettings()\r\n     */\r\n    readonly schema: Readonly<RxJsonSchema<RxDocumentData<RxDocType>>>;\r\n    readonly collectionName: string;\r\n\r\n    /**\r\n     * (Optional) reference to the underlying persistent storage instance.\r\n     * If set, things like replication will run on that storageInstance instead of the parent.\r\n     * This is mostly used in things like the memory-synced storage where we want to\r\n     * run replications and migrations on the persistent storage instead of the in-memory storage.\r\n     *\r\n     * Having this is the least hacky option. The only other option would be to toggle all calls to the\r\n     * storageInstance by checking the givent context-string. But this would make it impossible\r\n     * to run a replication on the parentStorage itself.\r\n     */\r\n    readonly underlyingPersistentStorage?: RxStorageInstance<RxDocType, any, any, any>;\r\n\r\n    /**\r\n     * Writes multiple documents to the storage instance.\r\n     * The write for each single document is atomic, there\r\n     * is no transaction around all documents.\r\n     * The written documents must be the newest revision of that documents data.\r\n     * If the previous document is not the current newest revision, a conflict error\r\n     * must be returned.\r\n     * It must be possible that some document writes succeed\r\n     * and others error. We need this to have a similar behavior as most NoSQL databases.\r\n     */\r\n    bulkWrite(\r\n        documentWrites: BulkWriteRow<RxDocType>[],\r\n        /**\r\n         * Context will be used in all\r\n         * changeStream()-events that are emitted as a result\r\n         * of that bulkWrite() operation.\r\n         * Used in plugins so that we can detect that event X\r\n         * comes from operation Y.\r\n         */\r\n        context: string\r\n    ): Promise<RxStorageBulkWriteResponse<RxDocType>>;\r\n\r\n    /**\r\n     * Get Multiple documents by their primary value.\r\n     * This must also return deleted documents.\r\n     */\r\n    findDocumentsById(\r\n        /**\r\n         * List of primary values\r\n         * of the documents to find.\r\n         */\r\n        ids: string[],\r\n        /**\r\n         * If set to true, deleted documents will also be returned.\r\n         */\r\n        withDeleted: boolean\r\n\r\n    ): Promise<\r\n        /**\r\n         * For better performance, we return an array\r\n         * instead of an indexed object because most consumers\r\n         * of this anyway have to fill a Map() instance or\r\n         * even do only need the list at all.\r\n         */\r\n        RxDocumentData<RxDocType>[]\r\n    >;\r\n\r\n    /**\r\n     * Runs a NoSQL 'mango' query over the storage\r\n     * and returns the found documents data.\r\n     * Having all storage instances behave similar\r\n     * is likely the most difficult thing when creating a new\r\n     * rx-storage implementation.\r\n     */\r\n    query(\r\n        preparedQuery: PreparedQuery<RxDocType>\r\n    ): Promise<RxStorageQueryResult<RxDocType>>;\r\n\r\n    /**\r\n     * Returns the amount of non-deleted documents\r\n     * that match the given query.\r\n     * Sort, skip and limit of the query must be ignored!\r\n     */\r\n    count(\r\n        preparedQuery: PreparedQuery<RxDocType>\r\n    ): Promise<RxStorageCountResult>;\r\n\r\n    /**\r\n     * Returns the data of a single attachment as a Blob.\r\n     */\r\n    getAttachmentData(\r\n        documentId: string,\r\n        attachmentId: string,\r\n        digest: string\r\n    ): Promise<Blob>;\r\n\r\n    /**\r\n     * Returns the current (not the old!) data of all documents that have been changed AFTER the given checkpoint.\r\n     * If the returned array does not reach the limit, it can be assumed that the \"end\" is reached, when paginating over the changes.\r\n     * Also returns a new checkpoint for each document which can be used to continue with the pagination from that change on.\r\n     * Must never return the same document multiple times in the same call operation.\r\n     * This is used by RxDB to known what has changed since X so these docs can be handled by the backup or the replication\r\n     * plugin.\r\n     *\r\n     * Important: This method is optional. If not defined,\r\n     * RxDB will manually run a query and use the last returned document\r\n     * for checkpointing. In  the future we might even remove this method completely\r\n     * and let RxDB do the work instead of the RxStorage.\r\n     */\r\n    getChangedDocumentsSince?(\r\n        limit: number,\r\n        /**\r\n         * The checkpoint from with to start\r\n         * when the events are sorted in time.\r\n         * If we want to start from the beginning,\r\n         * undefined is used as a checkpoint.\r\n         */\r\n        checkpoint?: CheckpointType\r\n    ): Promise<{\r\n        documents: RxDocumentData<RxDocType>[];\r\n        /**\r\n         * The checkpoint contains data so that another\r\n         * call to getChangedDocumentsSince() will continue\r\n         * from exactly the last document that was returned before.\r\n         */\r\n        checkpoint: CheckpointType;\r\n    }>;\r\n\r\n    /**\r\n     * Returns an ongoing stream\r\n     * of all changes that happen to the\r\n     * storage instance.\r\n     * Do not forget to unsubscribe.\r\n     *\r\n     * If the RxStorage support multi-instance,\r\n     * and the storage is persistent,\r\n     * then the emitted changes of one RxStorageInstance\r\n     * must be also emitted to other instances with the same databaseName+collectionName.\r\n     * See ./rx-storage-multiinstance.ts\r\n     */\r\n    changeStream(): Observable<EventBulk<RxStorageChangeEvent<RxDocType>, CheckpointType>>;\r\n\r\n    /**\r\n     * Runs a cleanup that removes all tompstones\r\n     * of documents that have _deleted set to true\r\n     * to free up disc space.\r\n     *\r\n     * Returns true if all cleanable documents have been removed.\r\n     * Returns false if there are more documents to be cleaned up,\r\n     * but not all have been purged because that would block the storage for too long.\r\n     */\r\n    cleanup(\r\n        /**\r\n         * The minimum time in milliseconds\r\n         * of how long a document must have been deleted\r\n         * until it is purged by the cleanup.\r\n         */\r\n        minimumDeletedTime: number\r\n    ): Promise<\r\n        /**\r\n         * True if all docs cleaned up,\r\n         * false if there are more docs to clean up\r\n         */\r\n        boolean\r\n    >;\r\n\r\n    /**\r\n     * Closes the storage instance so it cannot be used\r\n     * anymore and should clear all memory.\r\n     * The returned promise must resolve when everything is cleaned up.\r\n     */\r\n    close(): Promise<void>;\r\n\r\n    /**\r\n     * Remove the database and\r\n     * deletes all of its data.\r\n     */\r\n    remove(): Promise<void>;\r\n}\r\n"],"mappings":"","ignoreList":[]}

package/dist/cjs/types/util.d.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=util.d.js.map

package/dist/cjs/types/util.d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.js","names":[],"sources":["../../../src/types/util.d.ts"],"sourcesContent":["import type { RxStorage } from './rx-storage.interface';\r\n\r\nexport type MaybePromise<T> = Promise<T> | T;\r\n\r\n\r\nexport type PlainJsonValue =\r\n    string |\r\n    number |\r\n    boolean |\r\n    PlainSimpleJsonObject |\r\n    PlainSimpleJsonObject[] |\r\n    PlainJsonValue[] |\r\n    { [key: string]: PlainJsonValue; }\r\n    ;\r\nexport type PlainSimpleJsonObject = {\r\n    [k: string]: PlainJsonValue | PlainJsonValue[];\r\n};\r\n\r\n/**\r\n * @link https://stackoverflow.com/a/49670389/3443137\r\n */\r\ntype DeepReadonly<T> =\r\n    T extends (infer R)[] ? DeepReadonlyArray<R> :\r\n    T extends Function ? T :\r\n    T extends object ? DeepReadonlyObject<T> :\r\n    T;\r\n\r\ninterface DeepReadonlyArray<T> extends ReadonlyArray<DeepReadonly<T>> { }\r\n\r\ntype DeepReadonlyObject<T> = {\r\n    readonly [P in keyof T]: DeepReadonly<T[P]>;\r\n};\r\n\r\nexport type MaybeReadonly<T> = T | Readonly<T>;\r\n\r\n\r\n/**\r\n * Opposite of DeepReadonly,\r\n * makes everything mutable again.\r\n */\r\ntype DeepMutable<T> = (\r\n    T extends object\r\n    ? {\r\n        -readonly [K in keyof T]: (\r\n            T[K] extends object\r\n            ? DeepMutable<T[K]>\r\n            : T[K]\r\n        )\r\n    }\r\n    : never\r\n);\r\n\r\n/**\r\n * Can be used like 'keyof'\r\n * but only represents the string keys, not the Symbols or numbers.\r\n * @link https://stackoverflow.com/a/51808262/3443137\r\n */\r\nexport type StringKeys<X> = Extract<keyof X, string>;\r\n\r\nexport type AnyKeys<T> = { [P in keyof T]?: T[P] | any };\r\nexport interface AnyObject {\r\n    [k: string]: any;\r\n}\r\n\r\n/**\r\n * @link https://dev.to/vborodulin/ts-how-to-override-properties-with-type-intersection-554l\r\n */\r\nexport type Override<T1, T2> = Omit<T1, keyof T2> & T2;\r\n\r\n\r\n\r\nexport type ById<T> = {\r\n    [id: string]: T;\r\n};\r\n\r\n/**\r\n * Must be async to support async hashing like from the WebCrypto API.\r\n * Accepts string for document revision hashing,\r\n * ArrayBuffer for raw binary hashing,\r\n * or Blob for attachment digest hashing.\r\n */\r\nexport type HashFunction = (input: string | ArrayBuffer | Blob) => Promise<string>;\r\n\r\nexport declare type QueryMatcher<DocType> = (doc: DocType | DeepReadonly<DocType>) => boolean;\r\n\r\n/**\r\n * To have a deterministic sorting, we cannot return 0,\r\n * we only return 1 or -1.\r\n * This ensures that we always end with the same output array, no mather of the\r\n * pre-sorting of the input array.\r\n */\r\nexport declare type DeterministicSortComparator<DocType> = (a: DocType, b: DocType) => 1 | -1;\r\n\r\n/**\r\n * To test a storage, we need these\r\n * configuration values.\r\n */\r\nexport type RxTestStorage = {\r\n    // can be used to setup async stuff\r\n    readonly init?: () => any;\r\n    readonly name: string;\r\n    readonly getStorage: () => RxStorage<any, any>;\r\n    /**\r\n     * Returns a storage that is used in performance tests.\r\n     * For example in a browser it should return the storage with an IndexedDB based adapter,\r\n     * while in node.js it must use the filesystem.\r\n     */\r\n    readonly getPerformanceStorage: () => {\r\n        storage: RxStorage<any, any>;\r\n        /**\r\n         * A description that describes the storage and setting.\r\n         * For example 'dexie-native'.\r\n         */\r\n        description: string;\r\n    };\r\n    /**\r\n     * True if the storage is able to\r\n     * keep data after an instance is closed and opened again.\r\n     */\r\n    readonly hasPersistence: boolean;\r\n    readonly hasMultiInstance: boolean;\r\n    readonly hasAttachments: boolean;\r\n\r\n    /**\r\n     * Some storages likes the memory-synced storage,\r\n     * are not able to provide a replication while guaranteeing\r\n     * data integrity.\r\n     */\r\n    readonly hasReplication: boolean;\r\n\r\n    /**\r\n     * To make it possible to test alternative encryption plugins,\r\n     * you can specify hasEncryption to signal\r\n     * the test runner that the given storage already contains an\r\n     * encryption plugin that should be used to test encryption tests.\r\n     * Otherwise the encryption-crypto-js plugin will be tested.\r\n     *\r\n     * hasEncryption must contain a function that is able\r\n     * to create a new password.\r\n     */\r\n    readonly hasEncryption?: () => Promise<string>;\r\n};\r\n\r\n\r\n/**\r\n * The paths as strings-type of nested object\r\n * @link https://stackoverflow.com/a/58436959/3443137\r\n */\r\ntype Join<K, P> = K extends string | number ?\r\n    P extends string | number ?\r\n    `${K}${'' extends P ? '' : '.'}${P}`\r\n    : never : never;\r\n\r\nexport type Paths<T, D extends number = 10> = [D] extends [never] ? never : T extends object ?\r\n    { [K in keyof T]-?: K extends string | number ?\r\n        `${K}` | (Paths<T[K], Prev[D]> extends infer R ? Join<K, R> : never)\r\n        : never\r\n    }[keyof T] : '';\r\n\r\nexport type Leaves<T, D extends number = 10> = [D] extends [never] ? never : T extends object ?\r\n    { [K in keyof T]-?: Join<K, Leaves<T[K], Prev[D]>> }[keyof T] : '';\r\ntype Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,\r\n    11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...0[]];\r\n\r\n\r\n\r\n/**\r\n * In the past, users had to add WeakRef to their typescript config.\r\n * To create an easier setup, we use our own typings instead, because WeakRef\r\n * is used internally only anyways.\r\n */\r\n\r\nexport interface WeakRef<T extends object = any> {\r\n    deref(): T | undefined;\r\n}\r\n\r\nexport interface FinalizationRegistry<T> {\r\n    register(target: object, heldValue: T, unregisterToken?: object): void;\r\n    unregister(unregisterToken: object): boolean;\r\n}\r\n"],"mappings":"","ignoreList":[]}

package/dist/esm/change-event-buffer.js

@@ -0,0 +1,141 @@
+/**
+ * a buffer-cache which holds the last X changeEvents of the collection
+ */
+
+import { filter } from 'rxjs/operators';
+import { requestIdlePromiseNoQueue } from "./plugins/utils/index.js";
+
+/**
+ * This buffer rembemers previous change events
+ * so that queries can use them on .exec()
+ * to calculate the new result set via event-reduce instead
+ * of running the query against the storage.
+ */
+export var ChangeEventBuffer = /*#__PURE__*/function () {
+  /**
+   * These properties are private to ensure they cannot
+   * be read without first processing the lazy tasks.
+   */
+
+  /**
+   * array with changeEvents
+   * starts with oldest known event, ends with newest
+  */
+
+  function ChangeEventBuffer(collection) {
+    this.subs = [];
+    this.counter = 0;
+    this.eventCounterMap = new WeakMap();
+    this.buffer = [];
+    this.limit = 100;
+    this.tasks = new Set();
+    this.collection = collection;
+    this.subs.push(this.collection.eventBulks$.pipe(filter(bulk => !bulk.isLocal)).subscribe(eventBulk => {
+      this.tasks.add(() => this._handleChangeEvents(eventBulk.events));
+      if (this.tasks.size <= 1) {
+        requestIdlePromiseNoQueue().then(() => {
+          this.processTasks();
+        });
+      }
+    }));
+  }
+  var _proto = ChangeEventBuffer.prototype;
+  _proto.processTasks = function processTasks() {
+    if (this.tasks.size === 0) {
+      return;
+    }
+    var tasks = Array.from(this.tasks);
+    tasks.forEach(task => task());
+    this.tasks.clear();
+  };
+  _proto._handleChangeEvents = function _handleChangeEvents(events) {
+    var counterBefore = this.counter;
+    this.counter = this.counter + events.length;
+    if (events.length > this.limit) {
+      this.buffer = events.slice(events.length * -1);
+    } else {
+      this.buffer = this.buffer.concat(events);
+      this.buffer = this.buffer.slice(this.limit * -1);
+    }
+    var counterBase = counterBefore + 1;
+    var eventCounterMap = this.eventCounterMap;
+    for (var index = 0; index < events.length; index++) {
+      var event = events[index];
+      eventCounterMap.set(event, counterBase + index);
+    }
+  };
+  _proto.getCounter = function getCounter() {
+    this.processTasks();
+    return this.counter;
+  };
+  _proto.getBuffer = function getBuffer() {
+    this.processTasks();
+    return this.buffer;
+  }
+
+  /**
+   * gets the array-index for the given pointer
+   * @return arrayIndex which can be used to iterate from there. If null, pointer is out of lower bound
+   */;
+  _proto.getArrayIndexByPointer = function getArrayIndexByPointer(pointer) {
+    this.processTasks();
+    var oldestEvent = this.buffer[0];
+    var oldestCounter = this.eventCounterMap.get(oldestEvent);
+    if (pointer < oldestCounter) return null; // out of bounds
+
+    var rest = pointer - oldestCounter;
+    return rest;
+  }
+
+  /**
+   * get all changeEvents which came in later than the pointer-event
+   * @return array with change-events. If null, pointer out of bounds
+   */;
+  _proto.getFrom = function getFrom(pointer) {
+    this.processTasks();
+    var ret = [];
+    var currentIndex = this.getArrayIndexByPointer(pointer);
+    if (currentIndex === null)
+      // out of bounds
+      return null;
+    while (true) {
+      var nextEvent = this.buffer[currentIndex];
+      currentIndex++;
+      if (!nextEvent) {
+        return ret;
+      } else {
+        ret.push(nextEvent);
+      }
+    }
+  };
+  _proto.runFrom = function runFrom(pointer, fn) {
+    this.processTasks();
+    var ret = this.getFrom(pointer);
+    if (ret === null) {
+      throw new Error('out of bounds');
+    } else {
+      ret.forEach(cE => fn(cE));
+    }
+  }
+
+  /**
+   * no matter how many operations are done on one document,
+   * only the last operation has to be checked to calculate the new state
+   * this function reduces the events to the last ChangeEvent of each doc.
+   * This functionality is currently disabled. It is questionable if
+   * pre-merging the events would really be faster or actually slower.
+   */;
+  _proto.reduceByLastOfDoc = function reduceByLastOfDoc(changeEvents) {
+    this.processTasks();
+    return changeEvents.slice(0);
+  };
+  _proto.close = function close() {
+    this.tasks.clear();
+    this.subs.forEach(sub => sub.unsubscribe());
+  };
+  return ChangeEventBuffer;
+}();
+export function createChangeEventBuffer(collection) {
+  return new ChangeEventBuffer(collection);
+}
+//# sourceMappingURL=change-event-buffer.js.map

package/dist/esm/change-event-buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-event-buffer.js","names":["filter","requestIdlePromiseNoQueue","ChangeEventBuffer","collection","subs","counter","eventCounterMap","WeakMap","buffer","limit","tasks","Set","push","eventBulks$","pipe","bulk","isLocal","subscribe","eventBulk","add","_handleChangeEvents","events","size","then","processTasks","_proto","prototype","Array","from","forEach","task","clear","counterBefore","length","slice","concat","counterBase","index","event","set","getCounter","getBuffer","getArrayIndexByPointer","pointer","oldestEvent","oldestCounter","get","rest","getFrom","ret","currentIndex","nextEvent","runFrom","fn","Error","cE","reduceByLastOfDoc","changeEvents","close","sub","unsubscribe","createChangeEventBuffer"],"sources":["../../src/change-event-buffer.ts"],"sourcesContent":["/**\r\n * a buffer-cache which holds the last X changeEvents of the collection\r\n */\r\nimport {\r\n    Subscription\r\n} from 'rxjs';\r\nimport { filter } from 'rxjs/operators';\r\nimport type {\r\n    RxChangeEventBulk,\r\n    RxCollection,\r\n    RxStorageChangeEvent\r\n} from './types/index.d.ts';\r\nimport {\r\n    requestIdlePromiseNoQueue\r\n} from './plugins/utils/index.ts';\r\n\r\n\r\n/**\r\n * This buffer rembemers previous change events\r\n * so that queries can use them on .exec()\r\n * to calculate the new result set via event-reduce instead\r\n * of running the query against the storage.\r\n */\r\nexport class ChangeEventBuffer<RxDocType> {\r\n    /**\r\n     * These properties are private to ensure they cannot\r\n     * be read without first processing the lazy tasks.\r\n     */\r\n    private subs: Subscription[] = [];\r\n    private counter: number = 0;\r\n    private eventCounterMap: WeakMap<\r\n        RxStorageChangeEvent<RxDocType>,\r\n        number\r\n    > = new WeakMap();\r\n    /**\r\n     * array with changeEvents\r\n     * starts with oldest known event, ends with newest\r\n    */\r\n    private buffer: RxStorageChangeEvent<RxDocType>[] = [];\r\n\r\n    public limit: number = 100;\r\n\r\n\r\n\r\n    private tasks = new Set<Function>();\r\n\r\n    constructor(\r\n        public collection: RxCollection\r\n    ) {\r\n        this.subs.push(\r\n            this.collection.eventBulks$.pipe(\r\n                filter((bulk: RxChangeEventBulk<RxDocType>) => !bulk.isLocal)\r\n            ).subscribe((eventBulk: RxChangeEventBulk<RxDocType>) => {\r\n                this.tasks.add(() => this._handleChangeEvents(eventBulk.events));\r\n                if (this.tasks.size <= 1) {\r\n                    requestIdlePromiseNoQueue().then(() => {\r\n                        this.processTasks();\r\n                    });\r\n                }\r\n            })\r\n        );\r\n    }\r\n\r\n    private processTasks() {\r\n        if (this.tasks.size === 0) {\r\n            return;\r\n        }\r\n        const tasks = Array.from(this.tasks);\r\n        tasks.forEach(task => task());\r\n        this.tasks.clear();\r\n    }\r\n\r\n    private _handleChangeEvents(events: RxStorageChangeEvent<RxDocType>[]) {\r\n        const counterBefore = this.counter;\r\n        this.counter = this.counter + events.length;\r\n        if (events.length > this.limit) {\r\n            this.buffer = events.slice(events.length * -1);\r\n        } else {\r\n            this.buffer = this.buffer.concat(events);\r\n            this.buffer = this.buffer.slice(this.limit * -1);\r\n        }\r\n        const counterBase = counterBefore + 1;\r\n        const eventCounterMap = this.eventCounterMap;\r\n        for (let index = 0; index < events.length; index++) {\r\n            const event = events[index];\r\n            eventCounterMap.set(event, counterBase + index);\r\n        }\r\n    }\r\n\r\n    getCounter() {\r\n        this.processTasks();\r\n        return this.counter;\r\n    }\r\n    getBuffer() {\r\n        this.processTasks();\r\n        return this.buffer;\r\n    }\r\n\r\n    /**\r\n     * gets the array-index for the given pointer\r\n     * @return arrayIndex which can be used to iterate from there. If null, pointer is out of lower bound\r\n     */\r\n    getArrayIndexByPointer(pointer: number): number | null {\r\n        this.processTasks();\r\n        const oldestEvent = this.buffer[0];\r\n        const oldestCounter = this.eventCounterMap.get(\r\n            oldestEvent\r\n        ) as number;\r\n\r\n        if (pointer < oldestCounter)\r\n            return null; // out of bounds\r\n\r\n        const rest = pointer - oldestCounter;\r\n        return rest;\r\n    }\r\n\r\n    /**\r\n     * get all changeEvents which came in later than the pointer-event\r\n     * @return array with change-events. If null, pointer out of bounds\r\n     */\r\n    getFrom(pointer: number): RxStorageChangeEvent<RxDocType>[] | null {\r\n        this.processTasks();\r\n        const ret = [];\r\n        let currentIndex = this.getArrayIndexByPointer(pointer);\r\n        if (currentIndex === null) // out of bounds\r\n            return null;\r\n\r\n        while (true) {\r\n            const nextEvent = this.buffer[currentIndex];\r\n            currentIndex++;\r\n            if (!nextEvent) {\r\n                return ret;\r\n            } else {\r\n                ret.push(nextEvent);\r\n            }\r\n        }\r\n    }\r\n\r\n    runFrom(pointer: number, fn: Function) {\r\n        this.processTasks();\r\n        const ret = this.getFrom(pointer);\r\n        if (ret === null) {\r\n            throw new Error('out of bounds');\r\n        } else {\r\n            ret.forEach(cE => fn(cE));\r\n        }\r\n    }\r\n\r\n    /**\r\n     * no matter how many operations are done on one document,\r\n     * only the last operation has to be checked to calculate the new state\r\n     * this function reduces the events to the last ChangeEvent of each doc.\r\n     * This functionality is currently disabled. It is questionable if\r\n     * pre-merging the events would really be faster or actually slower.\r\n     */\r\n    reduceByLastOfDoc(changeEvents: RxStorageChangeEvent<RxDocType>[]): RxStorageChangeEvent<RxDocType>[] {\r\n        this.processTasks();\r\n        return changeEvents.slice(0);\r\n    }\r\n\r\n    close() {\r\n        this.tasks.clear();\r\n        this.subs.forEach(sub => sub.unsubscribe());\r\n    }\r\n}\r\n\r\nexport function createChangeEventBuffer<RxdocType>(\r\n    collection: RxCollection<RxdocType, any>\r\n) {\r\n    return new ChangeEventBuffer<RxdocType>(collection);\r\n}\r\n"],"mappings":"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","ignoreList":[]}