@connecttomahdi/rxdb 17.0.0-beta.17

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

@@ -0,0 +1,146 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ChangeEventBuffer = void 0;
+exports.createChangeEventBuffer = createChangeEventBuffer;
+var _operators = require("rxjs/operators");
+var _index = require("./plugins/utils/index.js");
+/**
+ * a buffer-cache which holds the last X changeEvents of the collection
+ */
+/**
+ * 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.
+ */
+var ChangeEventBuffer = exports.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((0, _operators.filter)(bulk => !bulk.isLocal)).subscribe(eventBulk => {
+      this.tasks.add(() => this._handleChangeEvents(eventBulk.events));
+      if (this.tasks.size <= 1) {
+        (0, _index.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;
+}();
+function createChangeEventBuffer(collection) {
+  return new ChangeEventBuffer(collection);
+}
+//# sourceMappingURL=change-event-buffer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"change-event-buffer.js","names":["_operators","require","_index","ChangeEventBuffer","exports","collection","subs","counter","eventCounterMap","WeakMap","buffer","limit","tasks","Set","push","eventBulks$","pipe","filter","bulk","isLocal","subscribe","eventBulk","add","_handleChangeEvents","events","size","requestIdlePromiseNoQueue","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":[]}

package/dist/cjs/custom-index.js

@@ -0,0 +1,284 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.changeIndexableStringByOneQuantum = changeIndexableStringByOneQuantum;
+exports.getIndexMeta = getIndexMeta;
+exports.getIndexStringLength = getIndexStringLength;
+exports.getIndexableStringMonad = getIndexableStringMonad;
+exports.getNumberIndexString = getNumberIndexString;
+exports.getPrimaryKeyFromIndexableString = getPrimaryKeyFromIndexableString;
+exports.getStartIndexStringFromLowerBound = getStartIndexStringFromLowerBound;
+exports.getStartIndexStringFromUpperBound = getStartIndexStringFromUpperBound;
+exports.getStringLengthOfIndexNumber = getStringLengthOfIndexNumber;
+var _rxSchemaHelper = require("./rx-schema-helper.js");
+var _index = require("./plugins/utils/index.js");
+var _queryPlanner = require("./query-planner.js");
+/**
+ * For some RxStorage implementations,
+ * we need to use our custom crafted indexes
+ * so we can easily iterate over them. And sort plain arrays of document data.
+ *
+ * We really often have to craft an index string for a given document.
+ * Performance of everything in this file is very important
+ * which is why the code sometimes looks strange.
+ * Run performance tests before and after you touch anything here!
+ */
+
+/**
+ * Prepare all relevant information
+ * outside of the returned function
+ * from getIndexableStringMonad()
+ * to save performance when the returned
+ * function is called many times.
+ */
+
+function getIndexMeta(schema, index) {
+  var fieldNameProperties = index.map(fieldName => {
+    var schemaPart = (0, _rxSchemaHelper.getSchemaByObjectPath)(schema, fieldName);
+    if (!schemaPart) {
+      throw new Error('not in schema: ' + fieldName);
+    }
+    var type = schemaPart.type;
+    var parsedLengths;
+    if (type === 'number' || type === 'integer') {
+      parsedLengths = getStringLengthOfIndexNumber(schemaPart);
+    }
+    var getValue = (0, _index.objectPathMonad)(fieldName);
+    var maxLength = schemaPart.maxLength ? schemaPart.maxLength : 0;
+    var getIndexStringPart;
+    if (type === 'string') {
+      getIndexStringPart = docData => {
+        var fieldValue = getValue(docData);
+        if (!fieldValue) {
+          fieldValue = '';
+        }
+        return fieldValue.padEnd(maxLength, ' ');
+      };
+    } else if (type === 'boolean') {
+      getIndexStringPart = docData => {
+        var fieldValue = getValue(docData);
+        return fieldValue ? '1' : '0';
+      };
+    } else {
+      // number
+      getIndexStringPart = docData => {
+        var fieldValue = getValue(docData);
+        return getNumberIndexString(parsedLengths, fieldValue);
+      };
+    }
+    var ret = {
+      fieldName,
+      schemaPart,
+      parsedLengths,
+      getValue,
+      getIndexStringPart
+    };
+    return ret;
+  });
+  return fieldNameProperties;
+}
+
+/**
+ * Crafts an indexable string that can be used
+ * to check if a document would be sorted below or above
+ * another documents, dependent on the index values.
+ * @monad for better performance
+ *
+ * IMPORTANT: Performance is really important here
+ * which is why we code so 'strange'.
+ * Always run performance tests when you want to
+ * change something in this method.
+ */
+function getIndexableStringMonad(schema, index) {
+  var fieldNameProperties = getIndexMeta(schema, index);
+  var fieldNamePropertiesAmount = fieldNameProperties.length;
+  var indexPartsFunctions = fieldNameProperties.map(r => r.getIndexStringPart);
+
+  /**
+   * @hotPath Performance of this function is very critical!
+   */
+  var ret = function (docData) {
+    var str = '';
+    for (var i = 0; i < fieldNamePropertiesAmount; ++i) {
+      str += indexPartsFunctions[i](docData);
+    }
+    return str;
+  };
+  return ret;
+}
+function getStringLengthOfIndexNumber(schemaPart) {
+  var minimum = Math.floor(schemaPart.minimum);
+  var maximum = Math.ceil(schemaPart.maximum);
+  var multipleOf = schemaPart.multipleOf;
+  var valueSpan = maximum - minimum;
+  var nonDecimals = valueSpan.toString().length;
+  var multipleOfParts = multipleOf.toString().split('.');
+  var decimals = 0;
+  if (multipleOfParts.length > 1) {
+    decimals = multipleOfParts[1].length;
+  }
+  return {
+    minimum,
+    maximum,
+    nonDecimals,
+    decimals,
+    roundedMinimum: minimum
+  };
+}
+function getIndexStringLength(schema, index) {
+  var fieldNameProperties = getIndexMeta(schema, index);
+  var length = 0;
+  fieldNameProperties.forEach(props => {
+    var schemaPart = props.schemaPart;
+    var type = schemaPart.type;
+    if (type === 'string') {
+      length += schemaPart.maxLength;
+    } else if (type === 'boolean') {
+      length += 1;
+    } else {
+      var parsedLengths = props.parsedLengths;
+      length = length + parsedLengths.nonDecimals + parsedLengths.decimals;
+    }
+  });
+  return length;
+}
+function getPrimaryKeyFromIndexableString(indexableString, primaryKeyLength) {
+  var paddedPrimaryKey = indexableString.slice(primaryKeyLength * -1);
+  // we can safely trim here because the primary key is not allowed to start or end with a space char.
+  var primaryKey = paddedPrimaryKey.trim();
+  return primaryKey;
+}
+function getNumberIndexString(parsedLengths, fieldValue) {
+  /**
+   * Ensure that the given value is in the boundaries
+   * of the schema, otherwise it would create a broken index string.
+   * This can happen for example if you have a minimum of 0
+   * and run a query like
+   * selector {
+   *  numField: { $gt: -1000 }
+   * }
+   */
+  if (typeof fieldValue === 'undefined') {
+    fieldValue = 0;
+  }
+  if (fieldValue < parsedLengths.minimum) {
+    fieldValue = parsedLengths.minimum;
+  }
+  if (fieldValue > parsedLengths.maximum) {
+    fieldValue = parsedLengths.maximum;
+  }
+  var nonDecimalsValueAsString = (Math.floor(fieldValue) - parsedLengths.roundedMinimum).toString();
+  var str = nonDecimalsValueAsString.padStart(parsedLengths.nonDecimals, '0');
+  if (parsedLengths.decimals > 0) {
+    var splitByDecimalPoint = fieldValue.toString().split('.');
+    var decimalValueAsString = splitByDecimalPoint.length > 1 ? splitByDecimalPoint[1] : '0';
+    str += decimalValueAsString.padEnd(parsedLengths.decimals, '0');
+  }
+  return str;
+}
+function getStartIndexStringFromLowerBound(schema, index, lowerBound) {
+  var str = '';
+  index.forEach((fieldName, idx) => {
+    var schemaPart = (0, _rxSchemaHelper.getSchemaByObjectPath)(schema, fieldName);
+    var bound = lowerBound[idx];
+    var type = schemaPart.type;
+    switch (type) {
+      case 'string':
+        var maxLength = (0, _index.ensureNotFalsy)(schemaPart.maxLength, 'maxLength not set');
+        if (typeof bound === 'string') {
+          str += bound.padEnd(maxLength, ' ');
+        } else {
+          // str += ''.padStart(maxLength, inclusiveStart ? ' ' : INDEX_MAX);
+          str += ''.padEnd(maxLength, ' ');
+        }
+        break;
+      case 'boolean':
+        if (bound === null) {
+          str += '0';
+        } else if (bound === _queryPlanner.INDEX_MIN) {
+          str += '0';
+        } else if (bound === _queryPlanner.INDEX_MAX) {
+          str += '1';
+        } else {
+          var boolToStr = bound ? '1' : '0';
+          str += boolToStr;
+        }
+        break;
+      case 'number':
+      case 'integer':
+        var parsedLengths = getStringLengthOfIndexNumber(schemaPart);
+        if (bound === null || bound === _queryPlanner.INDEX_MIN) {
+          var fillChar = '0';
+          str += fillChar.repeat(parsedLengths.nonDecimals + parsedLengths.decimals);
+        } else if (bound === _queryPlanner.INDEX_MAX) {
+          str += getNumberIndexString(parsedLengths, parsedLengths.maximum);
+        } else {
+          var add = getNumberIndexString(parsedLengths, bound);
+          str += add;
+        }
+        break;
+      default:
+        throw new Error('unknown index type ' + type);
+    }
+  });
+  return str;
+}
+function getStartIndexStringFromUpperBound(schema, index, upperBound) {
+  var str = '';
+  index.forEach((fieldName, idx) => {
+    var schemaPart = (0, _rxSchemaHelper.getSchemaByObjectPath)(schema, fieldName);
+    var bound = upperBound[idx];
+    var type = schemaPart.type;
+    switch (type) {
+      case 'string':
+        var maxLength = (0, _index.ensureNotFalsy)(schemaPart.maxLength, 'maxLength not set');
+        if (typeof bound === 'string' && bound !== _queryPlanner.INDEX_MAX) {
+          str += bound.padEnd(maxLength, ' ');
+        } else if (bound === _queryPlanner.INDEX_MIN) {
+          str += ''.padEnd(maxLength, ' ');
+        } else {
+          str += ''.padEnd(maxLength, _queryPlanner.INDEX_MAX);
+        }
+        break;
+      case 'boolean':
+        if (bound === null) {
+          str += '1';
+        } else {
+          var boolToStr = bound ? '1' : '0';
+          str += boolToStr;
+        }
+        break;
+      case 'number':
+      case 'integer':
+        var parsedLengths = getStringLengthOfIndexNumber(schemaPart);
+        if (bound === null || bound === _queryPlanner.INDEX_MAX) {
+          var fillChar = '9';
+          str += fillChar.repeat(parsedLengths.nonDecimals + parsedLengths.decimals);
+        } else if (bound === _queryPlanner.INDEX_MIN) {
+          var _fillChar = '0';
+          str += _fillChar.repeat(parsedLengths.nonDecimals + parsedLengths.decimals);
+        } else {
+          str += getNumberIndexString(parsedLengths, bound);
+        }
+        break;
+      default:
+        throw new Error('unknown index type ' + type);
+    }
+  });
+  return str;
+}
+
+/**
+ * Used in storages where it is not possible
+ * to define inclusiveEnd/inclusiveStart
+ */
+function changeIndexableStringByOneQuantum(str, direction) {
+  var lastChar = str.slice(-1);
+  var charCode = lastChar.charCodeAt(0);
+  charCode = charCode + direction;
+  var withoutLastChar = str.slice(0, -1);
+  return withoutLastChar + String.fromCharCode(charCode);
+}
+//# sourceMappingURL=custom-index.js.map

package/dist/cjs/custom-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-index.js","names":["_rxSchemaHelper","require","_index","_queryPlanner","getIndexMeta","schema","index","fieldNameProperties","map","fieldName","schemaPart","getSchemaByObjectPath","Error","type","parsedLengths","getStringLengthOfIndexNumber","getValue","objectPathMonad","maxLength","getIndexStringPart","docData","fieldValue","padEnd","getNumberIndexString","ret","getIndexableStringMonad","fieldNamePropertiesAmount","length","indexPartsFunctions","r","str","i","minimum","Math","floor","maximum","ceil","multipleOf","valueSpan","nonDecimals","toString","multipleOfParts","split","decimals","roundedMinimum","getIndexStringLength","forEach","props","getPrimaryKeyFromIndexableString","indexableString","primaryKeyLength","paddedPrimaryKey","slice","primaryKey","trim","nonDecimalsValueAsString","padStart","splitByDecimalPoint","decimalValueAsString","getStartIndexStringFromLowerBound","lowerBound","idx","bound","ensureNotFalsy","INDEX_MIN","INDEX_MAX","boolToStr","fillChar","repeat","add","getStartIndexStringFromUpperBound","upperBound","changeIndexableStringByOneQuantum","direction","lastChar","charCode","charCodeAt","withoutLastChar","String","fromCharCode"],"sources":["../../src/custom-index.ts"],"sourcesContent":["/**\r\n * For some RxStorage implementations,\r\n * we need to use our custom crafted indexes\r\n * so we can easily iterate over them. And sort plain arrays of document data.\r\n *\r\n * We really often have to craft an index string for a given document.\r\n * Performance of everything in this file is very important\r\n * which is why the code sometimes looks strange.\r\n * Run performance tests before and after you touch anything here!\r\n */\r\n\r\nimport {\r\n    getSchemaByObjectPath\r\n} from './rx-schema-helper.ts';\r\nimport type {\r\n    JsonSchema,\r\n    RxDocumentData,\r\n    RxJsonSchema\r\n} from './types/index.d.ts';\r\nimport {\r\n    ensureNotFalsy,\r\n    objectPathMonad,\r\n    ObjectPathMonadFunction\r\n} from './plugins/utils/index.ts';\r\nimport {\r\n    INDEX_MAX,\r\n    INDEX_MIN\r\n} from './query-planner.ts';\r\n\r\n\r\n/**\r\n * Prepare all relevant information\r\n * outside of the returned function\r\n * from getIndexableStringMonad()\r\n * to save performance when the returned\r\n * function is called many times.\r\n */\r\ntype IndexMetaField<RxDocType> = {\r\n    fieldName: string;\r\n    schemaPart: JsonSchema;\r\n    /*\r\n     * Only in number fields.\r\n     */\r\n    parsedLengths?: ParsedLengths;\r\n    getValue: ObjectPathMonadFunction<RxDocType>;\r\n    getIndexStringPart: (docData: RxDocumentData<RxDocType>) => string;\r\n};\r\n\r\nexport function getIndexMeta<RxDocType>(\r\n    schema: RxJsonSchema<RxDocumentData<RxDocType>>,\r\n    index: string[]\r\n): IndexMetaField<RxDocType>[] {\r\n    const fieldNameProperties: IndexMetaField<RxDocType>[] = index.map(fieldName => {\r\n        const schemaPart = getSchemaByObjectPath(\r\n            schema,\r\n            fieldName\r\n        );\r\n        if (!schemaPart) {\r\n            throw new Error('not in schema: ' + fieldName);\r\n        }\r\n        const type = schemaPart.type;\r\n        let parsedLengths: ParsedLengths | undefined;\r\n        if (type === 'number' || type === 'integer') {\r\n            parsedLengths = getStringLengthOfIndexNumber(\r\n                schemaPart\r\n            );\r\n        }\r\n\r\n        const getValue = objectPathMonad(fieldName);\r\n        const maxLength = schemaPart.maxLength ? schemaPart.maxLength : 0;\r\n\r\n        let getIndexStringPart: (docData: RxDocumentData<RxDocType>) => string;\r\n        if (type === 'string') {\r\n            getIndexStringPart = docData => {\r\n                let fieldValue = getValue(docData);\r\n                if (!fieldValue) {\r\n                    fieldValue = '';\r\n                }\r\n                return fieldValue.padEnd(maxLength, ' ');\r\n            };\r\n        } else if (type === 'boolean') {\r\n            getIndexStringPart = docData => {\r\n                const fieldValue = getValue(docData);\r\n                return fieldValue ? '1' : '0';\r\n            };\r\n        } else { // number\r\n            getIndexStringPart = docData => {\r\n                const fieldValue = getValue(docData);\r\n                return getNumberIndexString(\r\n                    parsedLengths as any,\r\n                    fieldValue\r\n                );\r\n            };\r\n        }\r\n\r\n        const ret: IndexMetaField<RxDocType> = {\r\n            fieldName,\r\n            schemaPart,\r\n            parsedLengths,\r\n            getValue,\r\n            getIndexStringPart\r\n        };\r\n        return ret;\r\n    });\r\n    return fieldNameProperties;\r\n}\r\n\r\n\r\n/**\r\n * Crafts an indexable string that can be used\r\n * to check if a document would be sorted below or above\r\n * another documents, dependent on the index values.\r\n * @monad for better performance\r\n *\r\n * IMPORTANT: Performance is really important here\r\n * which is why we code so 'strange'.\r\n * Always run performance tests when you want to\r\n * change something in this method.\r\n */\r\nexport function getIndexableStringMonad<RxDocType>(\r\n    schema: RxJsonSchema<RxDocumentData<RxDocType>>,\r\n    index: string[]\r\n): (docData: RxDocumentData<RxDocType>) => string {\r\n    const fieldNameProperties = getIndexMeta(schema, index);\r\n    const fieldNamePropertiesAmount = fieldNameProperties.length;\r\n    const indexPartsFunctions = fieldNameProperties.map(r => r.getIndexStringPart);\r\n\r\n\r\n    /**\r\n     * @hotPath Performance of this function is very critical!\r\n     */\r\n    const ret = function (docData: RxDocumentData<RxDocType>): string {\r\n        let str = '';\r\n        for (let i = 0; i < fieldNamePropertiesAmount; ++i) {\r\n            str += indexPartsFunctions[i](docData);\r\n        }\r\n        return str;\r\n    };\r\n    return ret;\r\n}\r\n\r\n\r\ndeclare type ParsedLengths = {\r\n    minimum: number;\r\n    maximum: number;\r\n    nonDecimals: number;\r\n    decimals: number;\r\n    roundedMinimum: number;\r\n};\r\nexport function getStringLengthOfIndexNumber(\r\n    schemaPart: JsonSchema\r\n): ParsedLengths {\r\n    const minimum = Math.floor(schemaPart.minimum as number);\r\n    const maximum = Math.ceil(schemaPart.maximum as number);\r\n    const multipleOf: number = schemaPart.multipleOf as number;\r\n\r\n    const valueSpan = maximum - minimum;\r\n    const nonDecimals = valueSpan.toString().length;\r\n\r\n    const multipleOfParts = multipleOf.toString().split('.');\r\n    let decimals = 0;\r\n    if (multipleOfParts.length > 1) {\r\n        decimals = multipleOfParts[1].length;\r\n    }\r\n    return {\r\n        minimum,\r\n        maximum,\r\n        nonDecimals,\r\n        decimals,\r\n        roundedMinimum: minimum\r\n    };\r\n}\r\n\r\nexport function getIndexStringLength<RxDocType>(\r\n    schema: RxJsonSchema<RxDocumentData<RxDocType>>,\r\n    index: string[]\r\n): number {\r\n    const fieldNameProperties = getIndexMeta(schema, index);\r\n    let length = 0;\r\n    fieldNameProperties.forEach(props => {\r\n        const schemaPart = props.schemaPart;\r\n        const type = schemaPart.type;\r\n\r\n        if (type === 'string') {\r\n            length += schemaPart.maxLength as number;\r\n        } else if (type === 'boolean') {\r\n            length += 1;\r\n        } else {\r\n            const parsedLengths = props.parsedLengths as ParsedLengths;\r\n            length = length + parsedLengths.nonDecimals + parsedLengths.decimals;\r\n        }\r\n\r\n    });\r\n    return length;\r\n}\r\n\r\n\r\nexport function getPrimaryKeyFromIndexableString(\r\n    indexableString: string,\r\n    primaryKeyLength: number\r\n): string {\r\n    const paddedPrimaryKey = indexableString.slice(primaryKeyLength * -1);\r\n    // we can safely trim here because the primary key is not allowed to start or end with a space char.\r\n    const primaryKey = paddedPrimaryKey.trim();\r\n    return primaryKey;\r\n}\r\n\r\n\r\nexport function getNumberIndexString(\r\n    parsedLengths: ParsedLengths,\r\n    fieldValue: number\r\n): string {\r\n    /**\r\n     * Ensure that the given value is in the boundaries\r\n     * of the schema, otherwise it would create a broken index string.\r\n     * This can happen for example if you have a minimum of 0\r\n     * and run a query like\r\n     * selector {\r\n     *  numField: { $gt: -1000 }\r\n     * }\r\n     */\r\n    if (typeof fieldValue === 'undefined') {\r\n        fieldValue = 0;\r\n    }\r\n    if (fieldValue < parsedLengths.minimum) {\r\n        fieldValue = parsedLengths.minimum;\r\n    }\r\n    if (fieldValue > parsedLengths.maximum) {\r\n        fieldValue = parsedLengths.maximum;\r\n    }\r\n\r\n    const nonDecimalsValueAsString = (Math.floor(fieldValue) - parsedLengths.roundedMinimum).toString();\r\n    let str = nonDecimalsValueAsString.padStart(parsedLengths.nonDecimals, '0');\r\n\r\n    if (parsedLengths.decimals > 0) {\r\n        const splitByDecimalPoint = fieldValue.toString().split('.');\r\n        const decimalValueAsString = splitByDecimalPoint.length > 1 ? splitByDecimalPoint[1] : '0';\r\n        str += decimalValueAsString.padEnd(parsedLengths.decimals, '0');\r\n    }\r\n    return str;\r\n}\r\n\r\nexport function getStartIndexStringFromLowerBound(\r\n    schema: RxJsonSchema<any>,\r\n    index: string[],\r\n    lowerBound: (string | boolean | number | null | undefined)[]\r\n): string {\r\n    let str = '';\r\n    index.forEach((fieldName, idx) => {\r\n        const schemaPart = getSchemaByObjectPath(\r\n            schema,\r\n            fieldName\r\n        );\r\n        const bound = lowerBound[idx];\r\n        const type = schemaPart.type;\r\n\r\n        switch (type) {\r\n            case 'string':\r\n                const maxLength = ensureNotFalsy(schemaPart.maxLength, 'maxLength not set');\r\n                if (typeof bound === 'string') {\r\n                    str += (bound as string).padEnd(maxLength, ' ');\r\n                } else {\r\n                    // str += ''.padStart(maxLength, inclusiveStart ? ' ' : INDEX_MAX);\r\n                    str += ''.padEnd(maxLength, ' ');\r\n                }\r\n                break;\r\n            case 'boolean':\r\n                if (bound === null) {\r\n                    str += '0';\r\n                } else if (bound === INDEX_MIN) {\r\n                    str += '0';\r\n                } else if (bound === INDEX_MAX) {\r\n                    str += '1';\r\n                } else {\r\n                    const boolToStr = bound ? '1' : '0';\r\n                    str += boolToStr;\r\n                }\r\n                break;\r\n            case 'number':\r\n            case 'integer':\r\n                const parsedLengths = getStringLengthOfIndexNumber(\r\n                    schemaPart\r\n                );\r\n                if (bound === null || bound === INDEX_MIN) {\r\n                    const fillChar = '0';\r\n                    str += fillChar.repeat(parsedLengths.nonDecimals + parsedLengths.decimals);\r\n                } else if (bound === INDEX_MAX) {\r\n                    str += getNumberIndexString(\r\n                        parsedLengths,\r\n                        parsedLengths.maximum\r\n                    );\r\n                } else {\r\n                    const add = getNumberIndexString(\r\n                        parsedLengths,\r\n                        bound as number\r\n                    );\r\n                    str += add;\r\n                }\r\n                break;\r\n            default:\r\n                throw new Error('unknown index type ' + type);\r\n        }\r\n    });\r\n    return str;\r\n}\r\n\r\n\r\nexport function getStartIndexStringFromUpperBound(\r\n    schema: RxJsonSchema<any>,\r\n    index: string[],\r\n    upperBound: (string | boolean | number | null | undefined)[]\r\n): string {\r\n    let str = '';\r\n    index.forEach((fieldName, idx) => {\r\n        const schemaPart = getSchemaByObjectPath(\r\n            schema,\r\n            fieldName\r\n        );\r\n        const bound = upperBound[idx];\r\n        const type = schemaPart.type;\r\n\r\n        switch (type) {\r\n            case 'string':\r\n                const maxLength = ensureNotFalsy(schemaPart.maxLength, 'maxLength not set');\r\n                if (typeof bound === 'string' && bound !== INDEX_MAX) {\r\n                    str += (bound as string).padEnd(maxLength, ' ');\r\n                } else if (bound === INDEX_MIN) {\r\n                    str += ''.padEnd(maxLength, ' ');\r\n                } else {\r\n                    str += ''.padEnd(maxLength, INDEX_MAX);\r\n                }\r\n                break;\r\n            case 'boolean':\r\n                if (bound === null) {\r\n                    str += '1';\r\n                } else {\r\n                    const boolToStr = bound ? '1' : '0';\r\n                    str += boolToStr;\r\n                }\r\n                break;\r\n            case 'number':\r\n            case 'integer':\r\n                const parsedLengths = getStringLengthOfIndexNumber(\r\n                    schemaPart\r\n                );\r\n                if (bound === null || bound === INDEX_MAX) {\r\n                    const fillChar = '9';\r\n                    str += fillChar.repeat(parsedLengths.nonDecimals + parsedLengths.decimals);\r\n                } else if (bound === INDEX_MIN) {\r\n                    const fillChar = '0';\r\n                    str += fillChar.repeat(parsedLengths.nonDecimals + parsedLengths.decimals);\r\n                } else {\r\n                    str += getNumberIndexString(\r\n                        parsedLengths,\r\n                        bound as number\r\n                    );\r\n                }\r\n                break;\r\n            default:\r\n                throw new Error('unknown index type ' + type);\r\n        }\r\n    });\r\n    return str;\r\n}\r\n\r\n/**\r\n * Used in storages where it is not possible\r\n * to define inclusiveEnd/inclusiveStart\r\n */\r\nexport function changeIndexableStringByOneQuantum(str: string, direction: 1 | -1): string {\r\n    const lastChar = str.slice(-1);\r\n    let charCode = lastChar.charCodeAt(0);\r\n    charCode = charCode + direction;\r\n    const withoutLastChar = str.slice(0, -1);\r\n    return withoutLastChar + String.fromCharCode(charCode);\r\n}\r\n"],"mappings":"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","ignoreList":[]}