@templmf/temp-solf-lmf 0.0.142 → 0.0.144

package/pfnededegaaopdmhkdmcofjmoldfiped/3.5.0_0/lib/zero-dependencies/fake-indexeddb/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/pfnededegaaopdmhkdmcofjmoldfiped/3.5.0_0/lib/zero-dependencies/fake-indexeddb/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/pfnededegaaopdmhkdmcofjmoldfiped/3.5.0_0/lib/zero-dependencies/fake-indexeddb/lib/FakeEventTarget.js

@@ -0,0 +1,104 @@
+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/pfnededegaaopdmhkdmcofjmoldfiped/3.5.0_0/lib/zero-dependencies/fake-indexeddb/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/pfnededegaaopdmhkdmcofjmoldfiped/3.5.0_0/lib/zero-dependencies/fake-indexeddb/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;

package/pfnededegaaopdmhkdmcofjmoldfiped/3.5.0_0/lib/zero-dependencies/fake-indexeddb/lib/ObjectStore.js

@@ -0,0 +1,172 @@
+import { ConstraintError, DataError } from "./errors.js";
+import extractKey from "./extractKey.js";
+import KeyGenerator from "./KeyGenerator.js";
+import RecordStore from "./RecordStore.js";
+// http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-object-store
+class ObjectStore {
+  deleted = false;
+  records = new RecordStore();
+  rawIndexes = new Map();
+  constructor(rawDatabase, name, keyPath, autoIncrement) {
+    this.rawDatabase = rawDatabase;
+    this.keyGenerator = autoIncrement === true ? new KeyGenerator() : null;
+    this.deleted = false;
+    this.name = name;
+    this.keyPath = keyPath;
+    this.autoIncrement = autoIncrement;
+  }
+
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-retrieving-a-value-from-an-object-store
+  getKey(key) {
+    const record = this.records.get(key);
+    return record !== undefined ? structuredClone(record.key) : undefined;
+  }
+
+  // http://w3c.github.io/IndexedDB/#retrieve-multiple-keys-from-an-object-store
+  getAllKeys(range, count) {
+    if (count === undefined || count === 0) {
+      count = Infinity;
+    }
+    const records = [];
+    for (const record of this.records.values(range)) {
+      records.push(structuredClone(record.key));
+      if (records.length >= count) {
+        break;
+      }
+    }
+    return records;
+  }
+
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-retrieving-a-value-from-an-object-store
+  getValue(key) {
+    const record = this.records.get(key);
+    return record !== undefined ? structuredClone(record.value) : undefined;
+  }
+
+  // http://w3c.github.io/IndexedDB/#retrieve-multiple-values-from-an-object-store
+  getAllValues(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/#dfn-steps-for-storing-a-record-into-an-object-store
+  storeRecord(newRecord, noOverwrite, rollbackLog) {
+    if (this.keyPath !== null) {
+      const key = extractKey(this.keyPath, newRecord.value);
+      if (key !== undefined) {
+        newRecord.key = key;
+      }
+    }
+    if (this.keyGenerator !== null && newRecord.key === undefined) {
+      if (rollbackLog) {
+        const keyGeneratorBefore = this.keyGenerator.num;
+        rollbackLog.push(() => {
+          if (this.keyGenerator) {
+            this.keyGenerator.num = keyGeneratorBefore;
+          }
+        });
+      }
+      newRecord.key = this.keyGenerator.next();
+
+      // Set in value if keyPath defiend but led to no key
+      // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-to-assign-a-key-to-a-value-using-a-key-path
+      if (this.keyPath !== null) {
+        if (Array.isArray(this.keyPath)) {
+          throw new Error("Cannot have an array key path in an object store with a key generator");
+        }
+        let remainingKeyPath = this.keyPath;
+        let object = newRecord.value;
+        let identifier;
+        let i = 0; // Just to run the loop at least once
+        while (i >= 0) {
+          if (typeof object !== "object") {
+            throw new DataError();
+          }
+          i = remainingKeyPath.indexOf(".");
+          if (i >= 0) {
+            identifier = remainingKeyPath.slice(0, i);
+            remainingKeyPath = remainingKeyPath.slice(i + 1);
+            if (!Object.hasOwn(object, identifier)) {
+              object[identifier] = {};
+            }
+            object = object[identifier];
+          }
+        }
+        identifier = remainingKeyPath;
+        object[identifier] = newRecord.key;
+      }
+    } else if (this.keyGenerator !== null && typeof newRecord.key === "number") {
+      this.keyGenerator.setIfLarger(newRecord.key);
+    }
+    const existingRecord = this.records.get(newRecord.key);
+    if (existingRecord) {
+      if (noOverwrite) {
+        throw new ConstraintError();
+      }
+      this.deleteRecord(newRecord.key, rollbackLog);
+    }
+    this.records.add(newRecord);
+    if (rollbackLog) {
+      rollbackLog.push(() => {
+        this.deleteRecord(newRecord.key);
+      });
+    }
+
+    // Update indexes
+    for (const rawIndex of this.rawIndexes.values()) {
+      if (rawIndex.initialized) {
+        rawIndex.storeRecord(newRecord);
+      }
+    }
+    return newRecord.key;
+  }
+
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-deleting-records-from-an-object-store
+  deleteRecord(key, rollbackLog) {
+    const deletedRecords = this.records.delete(key);
+    if (rollbackLog) {
+      for (const record of deletedRecords) {
+        rollbackLog.push(() => {
+          this.storeRecord(record, true);
+        });
+      }
+    }
+    for (const rawIndex of this.rawIndexes.values()) {
+      rawIndex.records.deleteByValue(key);
+    }
+  }
+
+  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-clearing-an-object-store
+  clear(rollbackLog) {
+    const deletedRecords = this.records.clear();
+    if (rollbackLog) {
+      for (const record of deletedRecords) {
+        rollbackLog.push(() => {
+          this.storeRecord(record, true);
+        });
+      }
+    }
+    for (const rawIndex of this.rawIndexes.values()) {
+      rawIndex.records.clear();
+    }
+  }
+  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 ObjectStore;

package/pfnededegaaopdmhkdmcofjmoldfiped/3.5.0_0/lib/zero-dependencies/fake-indexeddb/lib/RecordStore.js

@@ -0,0 +1,133 @@
+import FDBKeyRange from "../FDBKeyRange.js";
+import { getByKey, getByKeyRange, getIndexByKey, getIndexByKeyGTE, getIndexByKeyRange } from "./binarySearch.js";
+import cmp from "./cmp.js";
+class RecordStore {
+  records = [];
+  get(key) {
+    if (key instanceof FDBKeyRange) {
+      return getByKeyRange(this.records, key);
+    }
+    return getByKey(this.records, key);
+  }
+  add(newRecord) {
+    // Find where to put it so it's sorted by key
+    let i;
+    if (this.records.length === 0) {
+      i = 0;
+    } else {
+      i = getIndexByKeyGTE(this.records, newRecord.key);
+      if (i === -1) {
+        // If no matching key, add to end
+        i = this.records.length;
+      } else {
+        // If matching key, advance to appropriate position based on value (used in indexes)
+        while (i < this.records.length && cmp(this.records[i].key, newRecord.key) === 0) {
+          if (cmp(this.records[i].value, newRecord.value) !== -1) {
+            // Record value >= newRecord value, so insert here
+            break;
+          }
+          i += 1; // Look at next record
+        }
+      }
+    }
+    this.records.splice(i, 0, newRecord);
+  }
+  delete(key) {
+    const deletedRecords = [];
+    const isRange = key instanceof FDBKeyRange;
+    while (true) {
+      const idx = isRange ? getIndexByKeyRange(this.records, key) : getIndexByKey(this.records, key);
+      if (idx === -1) {
+        break;
+      }
+      deletedRecords.push(this.records[idx]);
+      this.records.splice(idx, 1);
+    }
+    return deletedRecords;
+  }
+  deleteByValue(key) {
+    const range = key instanceof FDBKeyRange ? key : FDBKeyRange.only(key);
+    const deletedRecords = [];
+    this.records = this.records.filter(record => {
+      const shouldDelete = range.includes(record.value);
+      if (shouldDelete) {
+        deletedRecords.push(record);
+      }
+      return !shouldDelete;
+    });
+    return deletedRecords;
+  }
+  clear() {
+    const deletedRecords = this.records.slice();
+    this.records = [];
+    return deletedRecords;
+  }
+  values(range, direction = "next") {
+    return {
+      [Symbol.iterator]: () => {
+        let i;
+        if (direction === "next") {
+          i = 0;
+          if (range !== undefined && range.lower !== undefined) {
+            while (this.records[i] !== undefined) {
+              const cmpResult = cmp(this.records[i].key, range.lower);
+              if (cmpResult === 1 || cmpResult === 0 && !range.lowerOpen) {
+                break;
+              }
+              i += 1;
+            }
+          }
+        } else {
+          i = this.records.length - 1;
+          if (range !== undefined && range.upper !== undefined) {
+            while (this.records[i] !== undefined) {
+              const cmpResult = cmp(this.records[i].key, range.upper);
+              if (cmpResult === -1 || cmpResult === 0 && !range.upperOpen) {
+                break;
+              }
+              i -= 1;
+            }
+          }
+        }
+        return {
+          next: () => {
+            let done;
+            let value;
+            if (direction === "next") {
+              value = this.records[i];
+              done = i >= this.records.length;
+              i += 1;
+              if (!done && range !== undefined && range.upper !== undefined) {
+                const cmpResult = cmp(value.key, range.upper);
+                done = cmpResult === 1 || cmpResult === 0 && range.upperOpen;
+                if (done) {
+                  value = undefined;
+                }
+              }
+            } else {
+              value = this.records[i];
+              done = i < 0;
+              i -= 1;
+              if (!done && range !== undefined && range.lower !== undefined) {
+                const cmpResult = cmp(value.key, range.lower);
+                done = cmpResult === -1 || cmpResult === 0 && range.lowerOpen;
+                if (done) {
+                  value = undefined;
+                }
+              }
+            }
+
+            // The weird "as IteratorResult<Record>" is needed because of
+            // https://github.com/Microsoft/TypeScript/issues/11375 and
+            // https://github.com/Microsoft/TypeScript/issues/2983
+            return {
+              done,
+              value
+            };
+          }
+        };
+      }
+    };
+  }
+}
+export default RecordStore;