@react-native-firebase/app 20.0.0 → 20.2.0

package/lib/internal/web/memidb/LICENSE

@@ -0,0 +1,208 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction, and
+    distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by the
+    copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all other
+    entities that control, are controlled by, or are under common control with
+    that entity. For the purposes of this definition, "control" means (i) the
+    power, direct or indirect, to cause the direction or management of such
+    entity, whether by contract or otherwise, or (ii) ownership of
+    fifty percent (50%) or more of the outstanding shares, or (iii) beneficial
+    ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity exercising
+    permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation source,
+    and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical transformation
+    or translation of a Source form, including but not limited to compiled
+    object code, generated documentation, and conversions to
+    other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or Object
+    form, made available under the License, as indicated by a copyright notice
+    that is included in or attached to the work (an example is provided in the
+    Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object form,
+    that is based on (or derived from) the Work and for which the editorial
+    revisions, annotations, elaborations, or other modifications represent,
+    as a whole, an original work of authorship. For the purposes of this
+    License, Derivative Works shall not include works that remain separable
+    from, or merely link (or bind by name) to the interfaces of, the Work and
+    Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including the original
+    version of the Work and any modifications or additions to that Work or
+    Derivative Works thereof, that is intentionally submitted to Licensor for
+    inclusion in the Work by the copyright owner or by an individual or
+    Legal Entity authorized to submit on behalf of the copyright owner.
+    For the purposes of this definition, "submitted" means any form of
+    electronic, verbal, or written communication sent to the Licensor or its
+    representatives, including but not limited to communication on electronic
+    mailing lists, source code control systems, and issue tracking systems
+    that are managed by, or on behalf of, the Licensor for the purpose of
+    discussing and improving the Work, but excluding communication that is
+    conspicuously marked or otherwise designated in writing by the copyright
+    owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity on
+    behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2. Grant of Copyright License.
+
+    Subject to the terms and conditions of this License, each Contributor
+    hereby grants to You a perpetual, worldwide, non-exclusive, no-charge,
+    royalty-free, irrevocable copyright license to reproduce, prepare
+    Derivative Works of, publicly display, publicly perform, sublicense,
+    and distribute the Work and such Derivative Works in
+    Source or Object form.
+
+3. Grant of Patent License.
+
+    Subject to the terms and conditions of this License, each Contributor
+    hereby grants to You a perpetual, worldwide, non-exclusive, no-charge,
+    royalty-free, irrevocable (except as stated in this section) patent
+    license to make, have made, use, offer to sell, sell, import, and
+    otherwise transfer the Work, where such license applies only to those
+    patent claims licensable by such Contributor that are necessarily
+    infringed by their Contribution(s) alone or by combination of their
+    Contribution(s) with the Work to which such Contribution(s) was submitted.
+    If You institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+    Contribution incorporated within the Work constitutes direct or
+    contributory patent infringement, then any patent licenses granted to
+    You under this License for that Work shall terminate as of the date such
+    litigation is filed.
+
+4. Redistribution.
+
+    You may reproduce and distribute copies of the Work or Derivative Works
+    thereof in any medium, with or without modifications, and in Source or
+    Object form, provided that You meet the following conditions:
+
+    1. You must give any other recipients of the Work or Derivative Works a
+    copy of this License; and
+
+    2. You must cause any modified files to carry prominent notices stating
+    that You changed the files; and
+
+    3. You must retain, in the Source form of any Derivative Works that You
+    distribute, all copyright, patent, trademark, and attribution notices from
+    the Source form of the Work, excluding those notices that do not pertain
+    to any part of the Derivative Works; and
+
+    4. If the Work includes a "NOTICE" text file as part of its distribution,
+    then any Derivative Works that You distribute must include a readable copy
+    of the attribution notices contained within such NOTICE file, excluding
+    those notices that do not pertain to any part of the Derivative Works,
+    in at least one of the following places: within a NOTICE text file
+    distributed as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or, within a
+    display generated by the Derivative Works, if and wherever such
+    third-party notices normally appear. The contents of the NOTICE file are
+    for informational purposes only and do not modify the License.
+    You may add Your own attribution notices within Derivative Works that You
+    distribute, alongside or as an addendum to the NOTICE text from the Work,
+    provided that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and may
+    provide additional or different license terms and conditions for use,
+    reproduction, or distribution of Your modifications, or for any such
+    Derivative Works as a whole, provided Your use, reproduction, and
+    distribution of the Work otherwise complies with the conditions
+    stated in this License.
+
+5. Submission of Contributions.
+
+    Unless You explicitly state otherwise, any Contribution intentionally
+    submitted for inclusion in the Work by You to the Licensor shall be under
+    the terms and conditions of this License, without any additional
+    terms or conditions. Notwithstanding the above, nothing herein shall
+    supersede or modify the terms of any separate license agreement you may
+    have executed with Licensor regarding such Contributions.
+
+6. Trademarks.
+
+    This License does not grant permission to use the trade names, trademarks,
+    service marks, or product names of the Licensor, except as required for
+    reasonable and customary use in describing the origin of the Work and
+    reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+    Unless required by applicable law or agreed to in writing, Licensor
+    provides the Work (and each Contributor provides its Contributions)
+    on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+    either express or implied, including, without limitation, any warranties
+    or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS
+    FOR A PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any risks
+    associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability.
+
+    In no event and under no legal theory, whether in tort
+    (including negligence), contract, or otherwise, unless required by
+    applicable law (such as deliberate and grossly negligent acts) or agreed
+    to in writing, shall any Contributor be liable to You for damages,
+    including any direct, indirect, special, incidental, or consequential
+    damages of any character arising as a result of this License or out of
+    the use or inability to use the Work (including but not limited to damages
+    for loss of goodwill, work stoppage, computer failure or malfunction,
+    or any and all other commercial damages or losses), even if such
+    Contributor has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+    While redistributing the Work or Derivative Works thereof, You may choose
+    to offer, and charge a fee for, acceptance of support, warranty,
+    indemnity, or other liability obligations and/or rights consistent with
+    this License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf of any
+    other Contributor, and only if You agree to indemnify, defend, and hold
+    each Contributor harmless for any liability incurred by, or claims
+    asserted against, such Contributor by reason of your accepting any such
+    warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work
+
+    To apply the Apache License to your work, attach the following boilerplate
+    notice, with the fields enclosed by brackets "[]" replaced with your own
+    identifying information. (Don't include the brackets!) The text should be
+    enclosed in the appropriate comment syntax for the file format. We also
+    recommend that a file or class name and description of purpose be included
+    on the same "printed page" as the copyright notice for easier
+    identification within third-party archives.
+
+        Copyright 2017 Jeremy Scheff
+
+
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+        or implied. See the License for the specific language governing
+        permissions and limitations under the License.

package/lib/internal/web/memidb/index.js

@@ -0,0 +1,39 @@
+import FDBFactory from './FDBFactory.js';
+import IDBCursor from './FDBCursor.js';
+import IDBCursorWithValue from './FDBCursorWithValue.js';
+import IDBDatabase from './FDBDatabase.js';
+import IDBFactory from './FDBFactory.js';
+import IDBIndex from './FDBIndex.js';
+import IDBKeyRange from './FDBKeyRange.js';
+import IDBObjectStore from './FDBObjectStore.js';
+import IDBOpenDBRequest from './FDBOpenDBRequest.js';
+import IDBRequest from './FDBRequest.js';
+import IDBTransaction from './FDBTransaction.js';
+import IDBVersionChangeEvent from './FDBVersionChangeEvent.js';
+import { makeStructuredCloneAvailable } from '../structuredClone';
+
+let idbAvailable = false;
+export function makeIDBAvailable() {
+  if (idbAvailable) {
+    return;
+  }
+  if (!global.window) {
+    global.window = {};
+  }
+  if (!window.indexedDB) {
+    makeStructuredCloneAvailable();
+    window.indexedDB = new FDBFactory();
+    window.IDBCursor = IDBCursor;
+    window.IDBCursorWithValue = IDBCursorWithValue;
+    window.IDBDatabase = IDBDatabase;
+    window.IDBFactory = IDBFactory;
+    window.IDBIndex = IDBIndex;
+    window.IDBKeyRange = IDBKeyRange;
+    window.IDBObjectStore = IDBObjectStore;
+    window.IDBOpenDBRequest = IDBOpenDBRequest;
+    window.IDBRequest = IDBRequest;
+    window.IDBTransaction = IDBTransaction;
+    window.IDBVersionChangeEvent = IDBVersionChangeEvent;
+  }
+  idbAvailable = true;
+}

package/lib/internal/web/memidb/lib/Database.js

@@ -0,0 +1,32 @@
+import { queueTask } from './scheduling.js';
+
+// http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-database
+class Database {
+  deletePending = false;
+  transactions = [];
+  rawObjectStores = new Map();
+  connections = [];
+  constructor(name, version) {
+    this.name = name;
+    this.version = version;
+    this.processTransactions = this.processTransactions.bind(this);
+  }
+  processTransactions() {
+    queueTask(() => {
+      const anyRunning = this.transactions.some(transaction => {
+        return transaction._started && transaction._state !== 'finished';
+      });
+      if (!anyRunning) {
+        const next = this.transactions.find(transaction => {
+          return !transaction._started && transaction._state !== 'finished';
+        });
+        if (next) {
+          next.addEventListener('complete', this.processTransactions);
+          next.addEventListener('abort', this.processTransactions);
+          next._start();
+        }
+      }
+    });
+  }
+}
+export default Database;

package/lib/internal/web/memidb/lib/FakeDOMStringList.js

@@ -0,0 +1,72 @@
+class FakeDOMStringList extends Array {
+  contains(value) {
+    for (const value2 of this) {
+      if (value === value2) {
+        return true;
+      }
+    }
+    return false;
+  }
+  item(i) {
+    if (i < 0 || i >= this.length) {
+      return null;
+    }
+    return this[i];
+  }
+
+  // Used internally, should not be used by others. I could maybe get rid of these and replace rather than mutate, but too lazy to check the spec.
+  _push(...values) {
+    return Array.prototype.push.call(this, ...values);
+  }
+  _sort(...values) {
+    return Array.prototype.sort.call(this, ...values);
+  }
+}
+
+// Would be nice to remove these properties to fix https://github.com/dumbmatter/fakeIndexedDB/issues/66 but for some reason it breaks Dexie - see test/dexie.js and FakeDOMStringList tests
+/*
+// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
+const arrayPropertiesToDelete = ["from", "isArray", "of"];
+const arrayMethodsToDelete = [
+    "at",
+    "concat",
+    "copyWithin",
+    "entries",
+    "every",
+    "fill",
+    "filter",
+    "find",
+    "findIndex",
+    "flat",
+    "flatMap",
+    "forEach",
+    "includes",
+    "indexOf",
+    "join",
+    "keys",
+    "lastIndexOf",
+    "map",
+    "pop",
+    "push",
+    "reduce",
+    "reduceRight",
+    "reverse",
+    "shift",
+    "slice",
+    "some",
+    "sort",
+    "splice",
+    "unshift",
+    "values",
+];
+
+// Set to undefined rather than delete, so it doesn't go up the chain to Array. Not perfect, but good enough?
+for (const property of arrayPropertiesToDelete) {
+    (FakeDOMStringList as any)[property] = undefined;
+}
+for (const property of arrayMethodsToDelete) {
+    (FakeDOMStringList as any).prototype[property] = undefined;
+}
+*/
+
+export default FakeDOMStringList;

package/lib/internal/web/memidb/lib/FakeEvent.js

@@ -0,0 +1,38 @@
+class Event {
+  eventPath = [];
+  NONE = 0;
+  CAPTURING_PHASE = 1;
+  AT_TARGET = 2;
+  BUBBLING_PHASE = 3;
+
+  // Flags
+  propagationStopped = false;
+  immediatePropagationStopped = false;
+  canceled = false;
+  initialized = true;
+  dispatched = false;
+  target = null;
+  currentTarget = null;
+  eventPhase = 0;
+  defaultPrevented = false;
+  isTrusted = false;
+  timeStamp = Date.now();
+  constructor(type, eventInitDict = {}) {
+    this.type = type;
+    this.bubbles = eventInitDict.bubbles !== undefined ? eventInitDict.bubbles : false;
+    this.cancelable = eventInitDict.cancelable !== undefined ? eventInitDict.cancelable : false;
+  }
+  preventDefault() {
+    if (this.cancelable) {
+      this.canceled = true;
+    }
+  }
+  stopPropagation() {
+    this.propagationStopped = true;
+  }
+  stopImmediatePropagation() {
+    this.propagationStopped = true;
+    this.immediatePropagationStopped = true;
+  }
+}
+export default Event;

package/lib/internal/web/memidb/lib/FakeEventTarget.js

@@ -0,0 +1,110 @@
+import { InvalidStateError } from './errors.js';
+const stopped = (event, listener) => {
+  return (
+    event.immediatePropagationStopped ||
+    (event.eventPhase === event.CAPTURING_PHASE && listener.capture === false) ||
+    (event.eventPhase === event.BUBBLING_PHASE && listener.capture === true)
+  );
+};
+
+// http://www.w3.org/TR/dom/#concept-event-listener-invoke
+const invokeEventListeners = (event, obj) => {
+  event.currentTarget = obj;
+
+  // The callback might cause obj.listeners to mutate as we traverse it.
+  // Take a copy of the array so that nothing sneaks in and we don't lose
+  // our place.
+  for (const listener of obj.listeners.slice()) {
+    if (event.type !== listener.type || stopped(event, listener)) {
+      continue;
+    }
+
+    // @ts-ignore
+    listener.callback.call(event.currentTarget, event);
+  }
+  const typeToProp = {
+    abort: 'onabort',
+    blocked: 'onblocked',
+    complete: 'oncomplete',
+    error: 'onerror',
+    success: 'onsuccess',
+    upgradeneeded: 'onupgradeneeded',
+    versionchange: 'onversionchange',
+  };
+  const prop = typeToProp[event.type];
+  if (prop === undefined) {
+    throw new Error(`Unknown event type: "${event.type}"`);
+  }
+  const callback = event.currentTarget[prop];
+  if (callback) {
+    const listener = {
+      callback,
+      capture: false,
+      type: event.type,
+    };
+    if (!stopped(event, listener)) {
+      // @ts-ignore
+      listener.callback.call(event.currentTarget, event);
+    }
+  }
+};
+class FakeEventTarget {
+  listeners = [];
+
+  // These will be overridden in individual subclasses and made not readonly
+
+  addEventListener(type, callback, capture = false) {
+    this.listeners.push({
+      callback,
+      capture,
+      type,
+    });
+  }
+  removeEventListener(type, callback, capture = false) {
+    const i = this.listeners.findIndex(listener => {
+      return (
+        listener.type === type && listener.callback === callback && listener.capture === capture
+      );
+    });
+    this.listeners.splice(i, 1);
+  }
+
+  // http://www.w3.org/TR/dom/#dispatching-events
+  dispatchEvent(event) {
+    if (event.dispatched || !event.initialized) {
+      throw new InvalidStateError('The object is in an invalid state.');
+    }
+    event.isTrusted = false;
+    event.dispatched = true;
+    event.target = this;
+    // NOT SURE WHEN THIS SHOULD BE SET        event.eventPath = [];
+
+    event.eventPhase = event.CAPTURING_PHASE;
+    for (const obj of event.eventPath) {
+      if (!event.propagationStopped) {
+        invokeEventListeners(event, obj);
+      }
+    }
+    event.eventPhase = event.AT_TARGET;
+    if (!event.propagationStopped) {
+      invokeEventListeners(event, event.target);
+    }
+    if (event.bubbles) {
+      event.eventPath.reverse();
+      event.eventPhase = event.BUBBLING_PHASE;
+      for (const obj of event.eventPath) {
+        if (!event.propagationStopped) {
+          invokeEventListeners(event, obj);
+        }
+      }
+    }
+    event.dispatched = false;
+    event.eventPhase = event.NONE;
+    event.currentTarget = null;
+    if (event.canceled) {
+      return false;
+    }
+    return true;
+  }
+}
+export default FakeEventTarget;

package/lib/internal/web/memidb/lib/Index.js

@@ -0,0 +1,157 @@
+import { ConstraintError } from './errors.js';
+import extractKey from './extractKey.js';
+import RecordStore from './RecordStore.js';
+import valueToKey from './valueToKey.js';
+
+// http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-index
+class Index {
+  deleted = false;
+  // Initialized should be used to decide whether to throw an error or abort the versionchange transaction when there is a
+  // constraint
+  initialized = false;
+  records = new RecordStore();
+  constructor(rawObjectStore, name, keyPath, multiEntry, unique) {
+    this.rawObjectStore = rawObjectStore;
+    this.name = name;
+    this.keyPath = keyPath;
+    this.multiEntry = multiEntry;
+    this.unique = unique;
+  }
+
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-retrieving-a-value-from-an-index
+  getKey(key) {
+    const record = this.records.get(key);
+    return record !== undefined ? record.value : undefined;
+  }
+
+  // http://w3c.github.io/IndexedDB/#retrieve-multiple-referenced-values-from-an-index
+  getAllKeys(range, count) {
+    if (count === undefined || count === 0) {
+      count = Infinity;
+    }
+    const records = [];
+    for (const record of this.records.values(range)) {
+      records.push(structuredClone(record.value));
+      if (records.length >= count) {
+        break;
+      }
+    }
+    return records;
+  }
+
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#index-referenced-value-retrieval-operation
+  getValue(key) {
+    const record = this.records.get(key);
+    return record !== undefined ? this.rawObjectStore.getValue(record.value) : undefined;
+  }
+
+  // http://w3c.github.io/IndexedDB/#retrieve-multiple-referenced-values-from-an-index
+  getAllValues(range, count) {
+    if (count === undefined || count === 0) {
+      count = Infinity;
+    }
+    const records = [];
+    for (const record of this.records.values(range)) {
+      records.push(this.rawObjectStore.getValue(record.value));
+      if (records.length >= count) {
+        break;
+      }
+    }
+    return records;
+  }
+
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-storing-a-record-into-an-object-store (step 7)
+  storeRecord(newRecord) {
+    let indexKey;
+    try {
+      indexKey = extractKey(this.keyPath, newRecord.value);
+    } catch (err) {
+      if (err.name === 'DataError') {
+        // Invalid key is not an actual error, just means we do not store an entry in this index
+        return;
+      }
+      throw err;
+    }
+    if (!this.multiEntry || !Array.isArray(indexKey)) {
+      try {
+        valueToKey(indexKey);
+      } catch (e) {
+        return;
+      }
+    } else {
+      // remove any elements from index key that are not valid keys and remove any duplicate elements from index
+      // key such that only one instance of the duplicate value remains.
+      const keep = [];
+      for (const part of indexKey) {
+        if (keep.indexOf(part) < 0) {
+          try {
+            keep.push(valueToKey(part));
+          } catch (err) {
+            /* Do nothing */
+          }
+        }
+      }
+      indexKey = keep;
+    }
+    if (!this.multiEntry || !Array.isArray(indexKey)) {
+      if (this.unique) {
+        const existingRecord = this.records.get(indexKey);
+        if (existingRecord) {
+          throw new ConstraintError();
+        }
+      }
+    } else {
+      if (this.unique) {
+        for (const individualIndexKey of indexKey) {
+          const existingRecord = this.records.get(individualIndexKey);
+          if (existingRecord) {
+            throw new ConstraintError();
+          }
+        }
+      }
+    }
+    if (!this.multiEntry || !Array.isArray(indexKey)) {
+      this.records.add({
+        key: indexKey,
+        value: newRecord.key,
+      });
+    } else {
+      for (const individualIndexKey of indexKey) {
+        this.records.add({
+          key: individualIndexKey,
+          value: newRecord.key,
+        });
+      }
+    }
+  }
+  initialize(transaction) {
+    if (this.initialized) {
+      throw new Error('Index already initialized');
+    }
+    transaction._execRequestAsync({
+      operation: () => {
+        try {
+          // Create index based on current value of objectstore
+          for (const record of this.rawObjectStore.records.values()) {
+            this.storeRecord(record);
+          }
+          this.initialized = true;
+        } catch (err) {
+          // console.error(err);
+          transaction._abort(err.name);
+        }
+      },
+      source: null,
+    });
+  }
+  count(range) {
+    let count = 0;
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    for (const record of this.records.values(range)) {
+      count += 1;
+    }
+    return count;
+  }
+}
+export default Index;

package/lib/internal/web/memidb/lib/KeyGenerator.js

@@ -0,0 +1,22 @@
+import { ConstraintError } from './errors.js';
+const MAX_KEY = 9007199254740992;
+class KeyGenerator {
+  // This is kind of wrong. Should start at 1 and increment only after record is saved
+  num = 0;
+  next() {
+    if (this.num >= MAX_KEY) {
+      throw new ConstraintError();
+    }
+    this.num += 1;
+    return this.num;
+  }
+
+  // https://w3c.github.io/IndexedDB/#possibly-update-the-key-generator
+  setIfLarger(num) {
+    const value = Math.floor(Math.min(num, MAX_KEY)) - 1;
+    if (value >= this.num) {
+      this.num = value + 1;
+    }
+  }
+}
+export default KeyGenerator;