@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/types/plugins/utils/index.d.ts

@@ -0,0 +1,20 @@
+export * from './utils-array.ts';
+export * from './utils-blob.ts';
+export * from './utils-base64.ts';
+export * from './utils-revision.ts';
+export * from './utils-document.ts';
+export * from './utils-hash.ts';
+export * from './utils-promise.ts';
+export * from './utils-regex.ts';
+export * from './utils-string.ts';
+export * from './utils-number.ts';
+export * from './utils-object-deep-equal.ts';
+export * from './utils-object-dot-prop.ts';
+export * from './utils-object.ts';
+export * from './utils-map.ts';
+export * from './utils-error.ts';
+export * from './utils-time.ts';
+export * from './utils-other.ts';
+export * from './utils-rxdb-version.ts';
+export * from './utils-global.ts';
+export * from './utils-premium.ts';

package/dist/types/plugins/utils/utils-array.d.ts

@@ -0,0 +1,40 @@
+import type { MaybePromise, MaybeReadonly } from '../../types/index.d.ts';
+export declare function lastOfArray<T>(ar: T[]): T | undefined;
+/**
+ * shuffle the given array
+ */
+export declare function shuffleArray<T>(arr: T[]): T[];
+export declare function randomOfArray<T>(arr: T[]): T;
+export declare function toArray<T>(input: T | T[] | Readonly<T> | Readonly<T[]>): T[];
+/**
+ * Split array with items into smaller arrays with items
+ * @link https://stackoverflow.com/a/7273794/3443137
+ */
+export declare function batchArray<T>(array: T[], batchSize: number): T[][];
+/**
+ * @link https://stackoverflow.com/a/15996017
+ */
+export declare function removeOneFromArrayIfMatches<T>(ar: T[], condition: (x: T) => boolean): T[];
+/**
+ * returns true if the supplied argument is either an Array<T> or a Readonly<Array<T>>
+ */
+export declare function isMaybeReadonlyArray(x: any): x is MaybeReadonly<any[]>;
+export declare function isOneItemOfArrayInOtherArray<T>(ar1: T[], ar2: T[]): boolean;
+/**
+ * Use this in array.filter() to remove all empty slots
+ * and have the correct typings afterwards.
+ * @link https://stackoverflow.com/a/46700791/3443137
+ */
+export declare function arrayFilterNotEmpty<TValue>(value: TValue | null | undefined): value is TValue;
+export declare function countUntilNotMatching<T>(ar: T[], matchingFn: (v: T, idx: number) => boolean): number;
+export declare function asyncFilter<T>(array: T[], predicate: (item: T, index: number, a: T[]) => MaybePromise<boolean>): Promise<T[]>;
+/**
+ * @link https://stackoverflow.com/a/3762735
+ */
+export declare function sumNumberArray(array: number[]): number;
+export declare function maxOfNumbers(arr: number[]): number;
+/**
+ * @link https://gist.github.com/telekosmos/3b62a31a5c43f40849bb
+ */
+export declare function uniqueArray(arrArg: string[]): string[];
+export declare function sortByObjectNumberProperty<T>(property: keyof T): (a: T, b: T) => number;

package/dist/types/plugins/utils/utils-base64.d.ts

@@ -0,0 +1,15 @@
+/**
+ * atob() and btoa() do not work well with non ascii chars,
+ * so we have to use these helper methods instead.
+ * @link https://stackoverflow.com/a/30106551/3443137
+ */
+export declare function b64EncodeUnicode(str: string): string;
+export declare function b64DecodeUnicode(str: string): string;
+/**
+ * @link https://stackoverflow.com/a/9458996/3443137
+ */
+export declare function arrayBufferToBase64(buffer: ArrayBuffer): string;
+/**
+ * @link https://stackoverflow.com/a/21797381
+ */
+export declare function base64ToArrayBuffer(base64: string): ArrayBuffer;

package/dist/types/plugins/utils/utils-blob.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Since RxDB 13.0.0 we only use Blob instead of falling back to Buffer,
+ * because Node.js >18 supports Blobs anyway.
+ */
+/**
+ * depending if we are on node or browser,
+ * we have to use Buffer(node) or Blob(browser)
+ */
+export declare function createBlob(data: string, type: string): Blob;
+export declare function createBlobFromBase64(base64String: string, type: string): Promise<Blob>;
+export declare function blobToString(blob: Blob | string): Promise<string>;
+export declare function blobToBase64String(blob: Blob | string): Promise<string>;

package/dist/types/plugins/utils/utils-document.d.ts

@@ -0,0 +1,26 @@
+import type { DeepReadonly, RxDocumentData, RxDocumentMeta, StringKeys, WithDeleted, WithDeletedAndAttachments } from '../../types/index.d.ts';
+/**
+ * We use 1 as minimum so that the value is never falsy.
+ * This const is used in several places because querying
+ * with a value lower than the minimum could give false results.
+ */
+export declare const RX_META_LWT_MINIMUM = 1;
+export declare function getDefaultRxDocumentMeta(): RxDocumentMeta;
+/**
+ * Returns a revision that is not valid.
+ * Use this to have correct typings
+ * while the storage wrapper anyway will overwrite the revision.
+ */
+export declare function getDefaultRevision(): string;
+export declare function stripMetaDataFromDocument<RxDocType>(docData: RxDocumentData<RxDocType>): RxDocType;
+/**
+ * Faster way to check the equality of document lists
+ * compared to doing a deep-equal.
+ * Here we only check the ids and revisions.
+ */
+export declare function areRxDocumentArraysEqual<RxDocType>(primaryPath: StringKeys<RxDocumentData<RxDocType>>, ar1: RxDocumentData<RxDocType>[], ar2: RxDocumentData<RxDocType>[]): boolean;
+export declare function getSortDocumentsByLastWriteTimeComparator<RxDocType>(primaryPath: string): (a: RxDocumentData<RxDocType>, b: RxDocumentData<RxDocType>) => number;
+export declare function sortDocumentsByLastWriteTime<RxDocType>(primaryPath: string, docs: RxDocumentData<RxDocType>[]): RxDocumentData<RxDocType>[];
+type AnyDocFormat<RxDocType> = RxDocType | WithDeleted<RxDocType> | RxDocumentData<RxDocType> | WithDeletedAndAttachments<RxDocType>;
+export declare function toWithDeleted<RxDocType>(docData: AnyDocFormat<RxDocType> | DeepReadonly<AnyDocFormat<RxDocType>>): WithDeleted<RxDocType>;
+export {};

package/dist/types/plugins/utils/utils-error.d.ts

@@ -0,0 +1,8 @@
+import type { PlainJsonError, RxError, RxTypeError } from '../../types/index.d.ts';
+/**
+ * Returns an error that indicates that a plugin is missing
+ * We do not throw a RxError because this should not be handled
+ * programmatically but by using the correct import
+ */
+export declare function pluginMissing(pluginKey: string): Error;
+export declare function errorToPlainJson(err: Error | TypeError | RxError | RxTypeError): PlainJsonError;

package/dist/types/plugins/utils/utils-global.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Can be used by some plugins to have a "global" object that
+ * can be imported and mutated at will.
+ */
+export declare const RXDB_UTILS_GLOBAL: any;

package/dist/types/plugins/utils/utils-hash.d.ts

@@ -0,0 +1,4 @@
+import type { HashFunction } from '../../types/index.d.ts';
+export declare function nativeSha256(input: string | ArrayBuffer | Blob): Promise<string>;
+export declare const defaultHashSha256: HashFunction;
+export declare function hashStringToNumber(str: string): number;

package/dist/types/plugins/utils/utils-map.d.ts

@@ -0,0 +1,2 @@
+export declare function getFromMapOrThrow<K, V>(map: Map<K, V> | WeakMap<any, V>, key: K): V;
+export declare function getFromMapOrCreate<MapIndex, MapValue>(map: Map<MapIndex, MapValue> | WeakMap<any, MapValue>, index: MapIndex, creator: () => MapValue, ifWasThere?: (value: MapValue) => void): MapValue;

package/dist/types/plugins/utils/utils-number.d.ts

@@ -0,0 +1,7 @@
+/**
+ * returns a random number
+ * @param  {number} [min=0] inclusive
+ * @param  {number} [max=1000] inclusive
+ * @return {number}
+ */
+export declare function randomNumber(min?: number, max?: number): number;

package/dist/types/plugins/utils/utils-object-deep-equal.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copied from the fast-deep-equal package
+ * because it does not support es modules and causes optimization bailouts.
+ * TODO use the npm package again when this is merged:
+ * @link https://github.com/epoberezkin/fast-deep-equal/pull/105
+ */
+export declare function deepEqual(a: any, b: any): boolean;

package/dist/types/plugins/utils/utils-object-dot-prop.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copied from
+ * @link https://github.com/sindresorhus/dot-prop/blob/main/index.js
+ * because it is currently an esm only module.
+ * TODO use the npm package again when RxDB is also fully esm.
+ */
+/**
+ * TODO we need some performance tests and improvements here.
+ */
+export declare function getProperty(object: any, path: string | string[], value?: any): any;
+export declare function setProperty(object: any, path: string, value: any): any;
+export declare function deleteProperty(object: any, path: string): boolean | undefined;
+export declare function hasProperty(object: any, path: string): boolean;
+export declare function deepKeys(object: any): any[];

package/dist/types/plugins/utils/utils-object.d.ts

@@ -0,0 +1,61 @@
+import type { DeepReadonlyObject } from '../../types/index.d.ts';
+export declare function deepFreeze<T>(o: T): T;
+/**
+ * To get specific nested path values from objects,
+ * RxDB normally uses the 'dot-prop' npm module.
+ * But when performance is really relevant, this is not fast enough.
+ * Instead we use a monad that can prepare some stuff up front
+ * and we can reuse the generated function.
+ */
+export type ObjectPathMonadFunction<T, R = any> = (obj: T) => R;
+export declare function objectPathMonad<T, R = any>(objectPath: string): ObjectPathMonadFunction<T, R>;
+export declare function getFromObjectOrThrow<V>(obj: {
+    [k: string]: V;
+}, key: string): V;
+/**
+ * returns a flattened object
+ * @link https://gist.github.com/penguinboy/762197
+ */
+export declare function flattenObject(ob: any): any;
+/**
+ * does a flat copy on the objects,
+ * is about 3 times faster than using deepClone
+ * @link https://jsperf.com/object-rest-spread-vs-clone/2
+ */
+export declare function flatClone<T>(obj: T | DeepReadonlyObject<T> | Readonly<T>): T;
+/**
+ * @link https://stackoverflow.com/a/11509718/3443137
+ */
+export declare function firstPropertyNameOfObject(obj: any): string;
+export declare function firstPropertyValueOfObject<T>(obj: {
+    [k: string]: T;
+}): T;
+/**
+ * deep-sort an object so its attributes are in lexical order.
+ * Also sorts the arrays inside of the object if no-array-sort not set
+ */
+export declare function sortObject(obj: any, noArraySort?: boolean): any;
+/**
+ * Deep clone a plain json object.
+ * Does not work with recursive stuff
+ * or non-plain-json.
+ * IMPORTANT: Performance of this is very important,
+ * do not change it without running performance tests!
+ *
+ * @link https://github.com/zxdong262/deep-copy/blob/master/src/index.ts
+ */
+declare function deepClone<T>(src: T | DeepReadonlyObject<T>): T;
+export declare const clone: typeof deepClone;
+/**
+ * overwrites the getter with the actual value
+ * Mostly used for caching stuff on the first run
+ */
+export declare function overwriteGetterForCaching<ValueType = any>(obj: any, getterName: string, value: ValueType): ValueType;
+export declare function hasDeepProperty(obj: any, property: string): boolean;
+/**
+ * Deeply checks if an object contains any property
+ * with the value of undefined
+ * If yes, returns the path to it.
+ */
+export declare function findUndefinedPath(obj: unknown, parentPath?: string): string | false;
+export {};

package/dist/types/plugins/utils/utils-other.d.ts

@@ -0,0 +1,20 @@
+export declare function runXTimes(xTimes: number, fn: (idx: number) => void): void;
+export declare function ensureNotFalsy<T>(obj: T | false | undefined | null, message?: string): T;
+export declare function ensureInteger(obj: unknown): number;
+/**
+ * Using shareReplay() without settings will not unsubscribe
+ * if there are no more subscribers.
+ * So we use these defaults.
+ * @link https://cartant.medium.com/rxjs-whats-changed-with-sharereplay-65c098843e95
+ */
+export declare const RXJS_SHARE_REPLAY_DEFAULTS: {
+    bufferSize: number;
+    refCount: boolean;
+};
+/**
+ * Dynamically add a name to a function
+ * so that it can later be found in the stack.
+ * @link https://stackoverflow.com/a/41854075/3443137
+ */
+export declare function nameFunction<T>(name: string, body: T): T;
+export declare function customFetchWithFixedHeaders(headers: any): (url: string | URL, options?: any) => Promise<Response>;

package/dist/types/plugins/utils/utils-premium.d.ts

@@ -0,0 +1,10 @@
+export declare const PREMIUM_FLAG_HASH = "6da4936d1425ff3a5c44c02342c6daf791d266be3ae8479b8ec59e261df41b93";
+export declare const NON_PREMIUM_COLLECTION_LIMIT = 999;
+/**
+ * Here we check if the premium flag has been set.
+ * This code exists in the open source version of RxDB.
+ * Yes you are allowed to fork the repo and just overwrite this function.
+ * However you might better spend this time developing your real project
+ * and supporting the RxDB efforts by buying premium.
+ */
+export declare function hasPremiumFlag(): Promise<boolean>;

package/dist/types/plugins/utils/utils-promise.d.ts

@@ -0,0 +1,43 @@
+/**
+ * returns a promise that resolves on the next tick
+ */
+export declare function nextTick(): Promise<void>;
+export declare function promiseWait(ms?: number): Promise<void>;
+export declare function promiseWaitSkippable(ms?: number): {
+    promise: Promise<void>;
+    skip: () => void;
+};
+export declare function toPromise<T>(maybePromise: Promise<T> | T): Promise<T>;
+/**
+ * returns true if promise is given
+ */
+export declare function isPromise(value: any): boolean;
+/**
+ * Reusing resolved promises has a better
+ * performance than creating new ones each time.
+ */
+export declare const PROMISE_RESOLVE_TRUE: Promise<true>;
+export declare const PROMISE_RESOLVE_FALSE: Promise<false>;
+export declare const PROMISE_RESOLVE_NULL: Promise<null>;
+export declare const PROMISE_RESOLVE_VOID: Promise<void>;
+export declare function requestIdlePromiseNoQueue(
+/**
+ * We always set a timeout!
+ * RxDB might be used on the server side where the
+ * server runs 24/4 on 99% CPU. So without a timeout
+ * this would never resolve which could cause a memory leak.
+ */
+timeout?: number | undefined): Promise<void>;
+export declare function requestIdlePromise(timeout?: number | undefined): Promise<void>;
+/**
+ * run the callback if requestIdleCallback available
+ * do nothing if not
+ * @link https://developer.mozilla.org/de/docs/Web/API/Window/requestIdleCallback
+ */
+export declare function requestIdleCallbackIfAvailable(fun: Function): void;
+/**
+ * like Promise.all() but runs in series instead of parallel
+ * @link https://github.com/egoist/promise.series/blob/master/index.js
+ * @param tasks array with functions that return a promise
+ */
+export declare function promiseSeries(tasks: Function[], initial?: any): Promise<any[]>;

package/dist/types/plugins/utils/utils-regex.d.ts

@@ -0,0 +1,2 @@
+export declare const REGEX_ALL_DOTS: RegExp;
+export declare const REGEX_ALL_PIPES: RegExp;

package/dist/types/plugins/utils/utils-revision.d.ts

@@ -0,0 +1,22 @@
+import type { RxDocumentData } from '../../types/index.d.ts';
+/**
+ * Parses the full revision.
+ * Do NOT use this if you only need the revision height,
+ * then use getHeightOfRevision() instead which is faster.
+ */
+export declare function parseRevision(revision: string): {
+    height: number;
+    hash: string;
+};
+/**
+ * @hotPath Performance is very important here
+ * because we need to parse the revision height very often.
+ * Uses indexOf + charCodeAt for maximum performance.
+ * Single-digit heights (most common) use a fast path
+ * that avoids parseInt entirely.
+ */
+export declare function getHeightOfRevision(revision: string): number;
+/**
+ * Creates the next write revision for a given document.
+ */
+export declare function createRevision<RxDocType>(databaseInstanceToken: string, previousDocData?: RxDocumentData<RxDocType>): string;

package/dist/types/plugins/utils/utils-rxdb-version.d.ts

@@ -0,0 +1,4 @@
+/**
+ * This file is replaced in the 'npm run build:version' script.
+ */
+export declare const RXDB_VERSION = "17.0.0-beta.17";

package/dist/types/plugins/utils/utils-rxdb-version.template.d.ts

@@ -0,0 +1,4 @@
+/**
+ * This file is replaced in the 'npm run build:version' script.
+ */
+export declare const RXDB_VERSION = "|PLACEHOLDER|";

package/dist/types/plugins/utils/utils-string.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Get a random string which can be used for many things in RxDB.
+ * The returned string is guaranteed to be a valid database name or collection name
+ * and also to be a valid JavaScript variable name.
+ *
+ * @link http://stackoverflow.com/a/1349426/3443137
+ */
+export declare function randomToken(length?: number): string;
+/**
+ * A random string that is never inside of any storage
+ */
+export declare const RANDOM_STRING = "Fz7SZXPmYJujkzjY1rpXWvlWBqoGAfAX";
+/**
+ * uppercase first char
+ */
+export declare function ucfirst(str: string): string;
+/**
+ * removes trailing and ending dots from the string
+ */
+export declare function trimDots(str: string): string;
+/**
+ * @link https://stackoverflow.com/a/44950500/3443137
+ */
+export declare function lastCharOfString(str: string): string;
+/**
+ * returns true if the given name is likely a folder path
+ */
+export declare function isFolderPath(name: string): boolean;
+/**
+ * @link https://gist.github.com/andreburgaud/6f73fd2d690b629346b8
+ * @link https://stackoverflow.com/a/76240378/3443137
+ */
+export declare function arrayBufferToString(arrayBuffer: Uint8Array<ArrayBuffer>): string;
+export declare function stringToArrayBuffer(str: string): Uint8Array<ArrayBuffer>;
+export declare function normalizeString(str: string): string;

package/dist/types/plugins/utils/utils-time.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns the current time in milliseconds,
+ * also ensures to not return the same value twice.
+ */
+export declare function now(): number;

package/dist/types/plugins/validate-ajv/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * this plugin validates documents before they can be inserted into the RxCollection.
+ * It's using ajv as jsonschema-validator
+ * @link https://github.com/epoberezkin/ajv
+ * @link https://github.com/ajv-validator/ajv/issues/2132#issuecomment-1537224620
+ */
+import Ajv from 'ajv';
+import type { RxDocumentData, RxJsonSchema } from '../../types/index.d.ts';
+export declare function getAjv(): Ajv;
+export declare function getValidator(schema: RxJsonSchema<any>): (docData: RxDocumentData<any>) => any;
+export declare const wrappedValidateAjvStorage: <Internals, InstanceCreationOptions>(args: {
+    storage: import("../../index.ts").RxStorage<Internals, InstanceCreationOptions>;
+}) => import("../../index.ts").RxStorage<Internals, InstanceCreationOptions>;

package/dist/types/plugins/validate-is-my-json-valid/index.d.ts

@@ -0,0 +1,5 @@
+import type { RxJsonSchema } from '../../types/index.d.ts';
+export declare function getValidator(schema: RxJsonSchema<any>): (docData: any) => any;
+export declare const wrappedValidateIsMyJsonValidStorage: <Internals, InstanceCreationOptions>(args: {
+    storage: import("../../index.ts").RxStorage<Internals, InstanceCreationOptions>;
+}) => import("../../index.ts").RxStorage<Internals, InstanceCreationOptions>;

package/dist/types/plugins/validate-z-schema/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * this plugin validates documents before they can be inserted into the RxCollection.
+ * It's using z-schema as jsonschema-validator
+ * @link https://github.com/zaggino/z-schema
+ */
+import ZSchema from 'z-schema';
+import type { RxJsonSchema } from '../../types/index.d.ts';
+export declare const ZSchemaClass: typeof ZSchema;
+export declare function getZSchema(): ZSchema;
+export declare function getValidator(schema: RxJsonSchema<any>): (docData: any) => any;
+export declare const wrappedValidateZSchemaStorage: <Internals, InstanceCreationOptions>(args: {
+    storage: import("../../index.ts").RxStorage<Internals, InstanceCreationOptions>;
+}) => import("../../index.ts").RxStorage<Internals, InstanceCreationOptions>;

package/dist/types/plugins/vector/index.d.ts

@@ -0,0 +1,2 @@
+export type * from './types.ts';
+export * from './vector-distance.ts';

package/dist/types/plugins/vector/types.d.ts

@@ -0,0 +1 @@
+export type Vector = number[];

package/dist/types/plugins/vector/vector-distance.d.ts

@@ -0,0 +1,13 @@
+import type { Vector } from './types';
+/**
+ * Vector comparison methods
+ * @link https://www.restack.io/p/vector-database-knowledge-answer-javascript-cat-ai
+ * @returns
+ */
+export declare function euclideanDistance(A: Vector, B: Vector): number;
+export declare function manhattanDistance(A: Vector, B: Vector): number;
+export declare function cosineSimilarity(A: Vector, B: Vector): number;
+/**
+ * @link https://github.com/vector5ai/vector5db/blob/main/src/metrics/JaccardSimilarity.ts
+ */
+export declare function jaccardSimilarity(a: number[], b: number[]): number;

package/dist/types/plugins/webmcp/index.d.ts

@@ -0,0 +1,2 @@
+export * from './webmcp.ts';
+export * from './nosql-query-schema.ts';