@connecttomahdi/rxdb 17.0.0-beta.17

package/src/plugins/utils/utils-map.ts

@@ -0,0 +1,23 @@
+export function getFromMapOrThrow<K, V>(map: Map<K, V> | WeakMap<any, V>, key: K): V {
+    const val = map.get(key);
+    if (typeof val === 'undefined') {
+        throw new Error('missing value from map ' + key);
+    }
+    return val;
+}
+
+export function getFromMapOrCreate<MapIndex, MapValue>(
+    map: Map<MapIndex, MapValue> | WeakMap<any, MapValue>,
+    index: MapIndex,
+    creator: () => MapValue,
+    ifWasThere?: (value: MapValue) => void
+): MapValue {
+    let value = map.get(index);
+    if (typeof value === 'undefined') {
+        value = creator();
+        map.set(index, value);
+    } else if (ifWasThere) {
+        ifWasThere(value);
+    }
+    return value;
+}

package/src/plugins/utils/utils-number.ts

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

package/src/plugins/utils/utils-object-deep-equal.ts

@@ -0,0 +1,46 @@
+
+/**
+ * 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 function deepEqual(a: any, b: any): boolean {
+    if (a === b) return true;
+
+    if (a && b && typeof a == 'object' && typeof b == 'object') {
+        if (a.constructor !== b.constructor) return false;
+
+        let length;
+        let i;
+        if (Array.isArray(a)) {
+            length = a.length;
+            if (length !== b.length) return false;
+            for (i = length; i-- !== 0;)
+                if (!deepEqual(a[i], b[i])) return false;
+            return true;
+        }
+
+
+        if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+        if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
+        if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
+
+        const keys = Object.keys(a);
+        length = keys.length;
+        if (length !== Object.keys(b).length) return false;
+
+        for (i = length; i-- !== 0;)
+            if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+
+        for (i = length; i-- !== 0;) {
+            const key = keys[i];
+            if (!deepEqual(a[key], b[key])) return false;
+        }
+
+        return true;
+    }
+
+    // true if both NaN, false otherwise
+    return a !== a && b !== b;
+}

package/src/plugins/utils/utils-object-dot-prop.ts

@@ -0,0 +1,365 @@
+/**
+ * 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.
+ */
+
+const isObject = (value: null) => {
+    const type = typeof value;
+    return value !== null && (type === 'object' || type === 'function');
+};
+
+const disallowedKeys = new Set([
+    '__proto__',
+    'prototype',
+    'constructor',
+]);
+
+const digits = new Set('0123456789');
+
+function getPathSegments(path: string) {
+    const parts = [];
+    let currentSegment = '';
+    let currentPart = 'start';
+    let isIgnoring = false;
+
+    for (const character of path) {
+        switch (character) {
+            case '\\': {
+                if (currentPart === 'index') {
+                    throw new Error('Invalid character in an index');
+                }
+
+                if (currentPart === 'indexEnd') {
+                    throw new Error('Invalid character after an index');
+                }
+
+                if (isIgnoring) {
+                    currentSegment += character;
+                }
+
+                currentPart = 'property';
+                isIgnoring = !isIgnoring;
+                break;
+            }
+
+            case '.': {
+                if (currentPart === 'index') {
+                    throw new Error('Invalid character in an index');
+                }
+
+                if (currentPart === 'indexEnd') {
+                    currentPart = 'property';
+                    break;
+                }
+
+                if (isIgnoring) {
+                    isIgnoring = false;
+                    currentSegment += character;
+                    break;
+                }
+
+                if (disallowedKeys.has(currentSegment)) {
+                    return [];
+                }
+
+                parts.push(currentSegment);
+                currentSegment = '';
+                currentPart = 'property';
+                break;
+            }
+
+            case '[': {
+                if (currentPart === 'index') {
+                    throw new Error('Invalid character in an index');
+                }
+
+                if (currentPart === 'indexEnd') {
+                    currentPart = 'index';
+                    break;
+                }
+
+                if (isIgnoring) {
+                    isIgnoring = false;
+                    currentSegment += character;
+                    break;
+                }
+
+                if (currentPart === 'property') {
+                    if (disallowedKeys.has(currentSegment)) {
+                        return [];
+                    }
+
+                    parts.push(currentSegment);
+                    currentSegment = '';
+                }
+
+                currentPart = 'index';
+                break;
+            }
+
+            case ']': {
+                if (currentPart === 'index') {
+                    parts.push(Number.parseInt(currentSegment, 10));
+                    currentSegment = '';
+                    currentPart = 'indexEnd';
+                    break;
+                }
+
+                if (currentPart === 'indexEnd') {
+                    throw new Error('Invalid character after an index');
+                }
+
+                // Falls through
+            }
+
+            default: {
+                if (currentPart === 'index' && !digits.has(character)) {
+                    throw new Error('Invalid character in an index');
+                }
+
+                if (currentPart === 'indexEnd') {
+                    throw new Error('Invalid character after an index');
+                }
+
+                if (currentPart === 'start') {
+                    currentPart = 'property';
+                }
+
+                if (isIgnoring) {
+                    isIgnoring = false;
+                    currentSegment += '\\';
+                }
+
+                currentSegment += character;
+            }
+        }
+    }
+
+    if (isIgnoring) {
+        currentSegment += '\\';
+    }
+
+    switch (currentPart) {
+        case 'property': {
+            if (disallowedKeys.has(currentSegment)) {
+                return [];
+            }
+
+            parts.push(currentSegment);
+
+            break;
+        }
+
+        case 'index': {
+            throw new Error('Index was not closed');
+        }
+
+        case 'start': {
+            parts.push('');
+
+            break;
+        }
+        // No default
+    }
+
+    return parts;
+}
+
+function isStringIndex(object: any[], key: string) {
+    if (typeof key !== 'number' && Array.isArray(object)) {
+        const index = Number.parseInt(key, 10);
+        return Number.isInteger(index) && object[index] === object[key as any];
+    }
+
+    return false;
+}
+
+function assertNotStringIndex(object: any, key: string | number) {
+    if (isStringIndex(object, key as any)) {
+        throw new Error('Cannot use string index');
+    }
+}
+
+/**
+ * TODO we need some performance tests and improvements here.
+ */
+export function getProperty(object: any, path: string | string[], value?: any) {
+    if (Array.isArray(path)) {
+        path = path.join('.');
+    }
+
+    /**
+     * Performance shortcut.
+     * In most cases we just have a simple property name
+     * so we can directly return it.
+     */
+    if (
+        !path.includes('.') &&
+        !path.includes('[')
+    ) {
+        return object[path];
+    }
+
+    if (!isObject(object as any) || typeof path !== 'string') {
+        return value === undefined ? object : value;
+    }
+
+    const pathArray = getPathSegments(path);
+    if (pathArray.length === 0) {
+        return value;
+    }
+
+    for (let index = 0; index < pathArray.length; index++) {
+        const key = pathArray[index];
+
+        if (isStringIndex(object as any, key as any)) {
+            object = index === pathArray.length - 1 ? undefined : null;
+        } else {
+            object = (object as any)[key];
+        }
+
+        if (object === undefined || object === null) {
+            // `object` is either `undefined` or `null` so we want to stop the loop, and
+            // if this is not the last bit of the path, and
+            // if it didn't return `undefined`
+            // it would return `null` if `object` is `null`
+            // but we want `get({foo: null}, 'foo.bar')` to equal `undefined`, or the supplied value, not `null`
+            if (index !== pathArray.length - 1) {
+                return value;
+            }
+
+            break;
+        }
+    }
+
+    return object === undefined ? value : object;
+}
+
+export function setProperty(object: any, path: string, value: any) {
+    if (Array.isArray(path)) {
+        path = path.join('.');
+    }
+
+    if (!isObject(object as any) || typeof path !== 'string') {
+        return object;
+    }
+
+    const root = object;
+    const pathArray = getPathSegments(path);
+
+    for (let index = 0; index < pathArray.length; index++) {
+        const key = pathArray[index];
+
+        assertNotStringIndex(object, key);
+
+        if (index === pathArray.length - 1) {
+            object[key] = value;
+        } else if (!isObject(object[key])) {
+            object[key] = typeof pathArray[index + 1] === 'number' ? [] : {};
+        }
+
+        object = object[key];
+    }
+
+    return root;
+}
+
+export function deleteProperty(object: any, path: string) {
+    if (!isObject(object as any) || typeof path !== 'string') {
+        return false;
+    }
+
+    const pathArray = getPathSegments(path);
+
+    for (let index = 0; index < pathArray.length; index++) {
+        const key = pathArray[index];
+
+        assertNotStringIndex(object, key);
+
+        if (index === pathArray.length - 1) {
+            delete object[key];
+            return true;
+        }
+
+        object = object[key];
+
+        if (!isObject(object as any)) {
+            return false;
+        }
+    }
+}
+
+export function hasProperty(object: any, path: string) {
+    if (!isObject(object) || typeof path !== 'string') {
+        return false;
+    }
+
+    const pathArray = getPathSegments(path);
+    if (pathArray.length === 0) {
+        return false;
+    }
+
+    for (const key of pathArray) {
+        if (!isObject(object) || !(key in object) || isStringIndex(object, key as any)) {
+            return false;
+        }
+
+        object = object[key];
+    }
+
+    return true;
+}
+
+// TODO: Backslashes with no effect should not be escaped
+function escapePath(path: string) {
+    if (typeof path !== 'string') {
+        throw new TypeError('Expected a string');
+    }
+
+    return path.replace(/[\\.[]/g, '\\$&');
+}
+
+// The keys returned by Object.entries() for arrays are strings
+function entries(value: any) {
+    if (Array.isArray(value)) {
+        return value.map((v, index) => [index, v]);
+    }
+
+    return Object.entries(value);
+}
+
+function stringifyPath(pathSegments: never[]) {
+    let result = '';
+
+    // eslint-disable-next-line prefer-const
+    for (let [index, segment] of entries(pathSegments)) {
+        if (typeof segment === 'number') {
+            result += `[${segment}]`;
+        } else {
+            segment = escapePath(segment);
+            result += index === 0 ? segment : `.${segment}`;
+        }
+    }
+
+    return result;
+}
+
+function* deepKeysIterator(object: any, currentPath = []): any {
+    if (!isObject(object)) {
+        if (currentPath.length > 0) {
+            yield stringifyPath(currentPath);
+        }
+
+        return;
+    }
+
+    for (const [key, value] of entries(object)) {
+        yield* deepKeysIterator(value, [...currentPath, key] as any);
+    }
+}
+
+export function deepKeys(object: any) {
+    return [...deepKeysIterator(object)];
+}

package/src/plugins/utils/utils-object.ts

@@ -0,0 +1,272 @@
+import type {
+    DeepReadonlyObject
+} from '../../types/index.d.ts';
+
+export function deepFreeze<T>(o: T): T {
+    Object.freeze(o);
+    Object.getOwnPropertyNames(o).forEach(function (prop) {
+        if (
+            Object.prototype.hasOwnProperty.call(o, prop) &&
+            (o as any)[prop] !== null &&
+            (
+                typeof (o as any)[prop] === 'object'
+                ||
+                typeof (o as any)[prop] === 'function'
+            ) &&
+            !Object.isFrozen((o as any)[prop])
+        ) {
+            deepFreeze((o as any)[prop]);
+        }
+    });
+    return o;
+}
+
+
+
+/**
+ * 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 function objectPathMonad<T, R = any>(objectPath: string): ObjectPathMonadFunction<T, R> {
+    const split = objectPath.split('.');
+
+    // reuse this variable for better performance.
+    const splitLength = split.length;
+
+    /**
+     * Performance shortcut,
+     * if no nested path is used,
+     * directly return the field of the object.
+     */
+    if (splitLength === 1) {
+        return (obj: T) => (obj as any)[objectPath];
+    }
+
+
+    return (obj: T) => {
+        let currentVal: any = obj;
+        for (let i = 0; i < splitLength; ++i) {
+            const subPath = split[i];
+            currentVal = currentVal[subPath];
+            if (typeof currentVal === 'undefined') {
+                return currentVal;
+            }
+        }
+        return currentVal;
+    };
+}
+
+
+export function getFromObjectOrThrow<V>(
+    obj: { [k: string]: V; },
+    key: string
+): V {
+    const val = obj[key];
+    if (!val) {
+        throw new Error('missing value from object ' + key);
+    }
+    return val;
+}
+
+/**
+ * returns a flattened object
+ * @link https://gist.github.com/penguinboy/762197
+ */
+export function flattenObject(ob: any) {
+    const toReturn: any = {};
+
+    for (const i in ob) {
+        if (!Object.prototype.hasOwnProperty.call(ob, i)) continue;
+        if ((typeof ob[i]) === 'object') {
+            const flatObject = flattenObject(ob[i]);
+            for (const x in flatObject) {
+                if (!Object.prototype.hasOwnProperty.call(flatObject, x)) continue;
+                toReturn[i + '.' + x] = flatObject[x];
+            }
+        } else {
+            toReturn[i] = ob[i];
+        }
+    }
+    return toReturn;
+}
+
+
+/**
+ * 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 function flatClone<T>(obj: T | DeepReadonlyObject<T> | Readonly<T>): T {
+    return Object.assign({}, obj) as any;
+}
+
+/**
+ * @link https://stackoverflow.com/a/11509718/3443137
+ */
+export function firstPropertyNameOfObject(obj: any): string {
+    return Object.keys(obj)[0];
+}
+export function firstPropertyValueOfObject<T>(obj: { [k: string]: T; }): T {
+    const key = Object.keys(obj)[0];
+    return obj[key];
+}
+
+
+/**
+ * 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 function sortObject(obj: any, noArraySort = false): any {
+    if (!obj) return obj; // do not sort null, false or undefined
+
+    // array
+    if (!noArraySort && Array.isArray(obj)) {
+        return obj
+            .sort((a, b) => {
+                if (typeof a === 'string' && typeof b === 'string')
+                    return a.localeCompare(b);
+
+                if (typeof a === 'object') return 1;
+                else return -1;
+            })
+            .map(i => sortObject(i, noArraySort));
+    }
+
+    // object
+    // array is also of type object
+    if (typeof obj === 'object' && !Array.isArray(obj)) {
+        const out: any = {};
+        Object.keys(obj)
+            .sort((a, b) => a.localeCompare(b))
+            .forEach(key => {
+                out[key] = sortObject(obj[key], noArraySort);
+            });
+        return out;
+    }
+
+    // everything else
+    return obj;
+}
+
+
+
+/**
+ * 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
+ */
+function deepClone<T>(src: T | DeepReadonlyObject<T>): T {
+    if (!src) {
+        return src;
+    }
+    if (src === null || typeof (src) !== 'object') {
+        return src;
+    }
+    // Blobs are immutable — pass through without cloning, otherwise it gets converted into a normal object, which breaks things.
+    if (typeof Blob !== 'undefined' && src instanceof Blob) {
+        return src as any;
+    }
+    if (Array.isArray(src)) {
+        const ret = new Array(src.length);
+        let i = ret.length;
+        while (i--) {
+            ret[i] = deepClone(src[i]);
+        }
+        return ret as any;
+    }
+    const dest: any = {};
+    // eslint-disable-next-line guard-for-in
+    for (const key in src) {
+        dest[key] = deepClone(src[key]);
+    }
+    return dest;
+}
+export const clone = deepClone;
+
+
+
+/**
+ * overwrites the getter with the actual value
+ * Mostly used for caching stuff on the first run
+ */
+export function overwriteGetterForCaching<ValueType = any>(
+    obj: any,
+    getterName: string,
+    value: ValueType
+): ValueType {
+    Object.defineProperty(obj, getterName, {
+        get: function () {
+            return value;
+        }
+    });
+    return value;
+}
+
+
+export function hasDeepProperty(obj: any, property: string): boolean {
+    if (obj.hasOwnProperty(property)) {
+        return true;
+    }
+
+    if (Array.isArray(obj)) {
+        const has = !!obj.find(item => hasDeepProperty(item, property));
+        return has;
+    }
+
+    // Recursively check for property in nested objects
+    for (const key in obj) {
+        if (typeof obj[key] === 'object' && obj[key] !== null) {
+            if (hasDeepProperty(obj[key], property)) {
+                return true;
+            }
+        }
+    }
+
+    // Return false if 'foobar' is not found at any level
+    return false;
+}
+
+
+/**
+ * Deeply checks if an object contains any property
+ * with the value of undefined
+ * If yes, returns the path to it.
+ */
+export function findUndefinedPath(obj: unknown, parentPath = ''): string | false {
+    // If `obj` is not an object or is null, we can't go deeper, so return false
+    if (typeof obj !== "object" || obj === null) {
+        return false;
+    }
+
+    for (const key of Object.keys(obj)) {
+        const value = (obj as Record<string, unknown>)[key];
+        // Build the full path. For the root level, it's just the key;
+        // for nested levels, prepend the parent path followed by a dot.
+        const currentPath = parentPath ? `${parentPath}.${key}` : key;
+
+        // If the value is undefined, return the path
+        if (typeof value === 'undefined') {
+            return currentPath;
+        }
+
+        // If the value is an object, recurse to check deeper
+        if (typeof value === "object" && value !== null) {
+            const result = findUndefinedPath(value, currentPath);
+            // If a path was found in the nested object, return it
+            if (result) {
+                return result;
+            }
+        }
+    }
+
+    // If no property with undefined was found
+    return false;
+}