@minnowdb/core 0.7.0 → 0.7.1

package/dist/engine/keyed-live.js

@@ -1,192 +1,187 @@
 import { dateMilliseconds } from "../date-value.js";
 import { sameLiveValue } from "./live-equal.js";
 function keyToken(value, name) {
-    if (typeof value === "string")
-        return `s:${String(value.length)}:${value}`;
-    if (typeof value === "boolean")
-        return value ? "b:1" : "b:0";
-    if (typeof value === "number") {
-        if (Number.isNaN(value))
-            return "n:NaN";
-        if (Object.is(value, -0))
-            return "n:-0";
-        return `n:${String(value)}`;
+  if (typeof value === "string")
+    return `s:${String(value.length)}:${value}`;
+  if (typeof value === "boolean")
+    return value ? "b:1" : "b:0";
+  if (typeof value === "number") {
+    if (Number.isNaN(value))
+      return "n:NaN";
+    if (Object.is(value, -0))
+      return "n:-0";
+    return `n:${String(value)}`;
+  }
+  if (value instanceof Date) {
+    const time = dateMilliseconds(value);
+    if (!Number.isFinite(time)) {
+      throw new TypeError(`Live query key ${String(name)} must be a valid Date`);
     }
-    if (value instanceof Date) {
-        const time = dateMilliseconds(value);
-        if (!Number.isFinite(time)) {
-            throw new TypeError(`Live query key ${String(name)} must be a valid Date`);
-        }
-        return `d:${String(time)}`;
-    }
-    throw new TypeError(`Live query key ${String(name)} must be a non-null string, number, boolean, or Date`);
+    return `d:${String(time)}`;
+  }
+  throw new TypeError(`Live query key ${String(name)} must be a non-null string, number, boolean, or Date`);
 }
 function indexRows(rows, key) {
-    const indexed = new Map();
-    for (let index = 0; index < rows.length; index += 1) {
-        const row = rows[index];
-        if (row === undefined)
-            continue;
-        const token = keyToken(row[key], key);
-        if (indexed.has(token)) {
-            throw new TypeError(`Live query key ${String(key)} is not unique: duplicate at row ${String(index)}`);
-        }
-        indexed.set(token, { row, index });
+  const indexed = /* @__PURE__ */ new Map();
+  for (let index = 0; index < rows.length; index += 1) {
+    const row = rows[index];
+    if (row === void 0)
+      continue;
+    const token = keyToken(row[key], key);
+    if (indexed.has(token)) {
+      throw new TypeError(`Live query key ${String(key)} is not unique: duplicate at row ${String(index)}`);
     }
-    return indexed;
+    indexed.set(token, { row, index });
+  }
+  return indexed;
 }
 function diffRows(previousRows, rows, key) {
-    const previous = indexRows(previousRows, key);
-    const current = indexRows(rows, key);
-    const changes = [];
-    for (const [token, old] of previous) {
-        if (current.has(token))
-            continue;
-        changes.push({ type: "delete", key: old.row[key], previous: old.row, index: old.index });
+  const previous = indexRows(previousRows, key);
+  const current = indexRows(rows, key);
+  const changes = [];
+  for (const [token, old] of previous) {
+    if (current.has(token))
+      continue;
+    changes.push({ type: "delete", key: old.row[key], previous: old.row, index: old.index });
+  }
+  for (const [token, next] of current) {
+    const old = previous.get(token);
+    if (old === void 0) {
+      changes.push({ type: "insert", row: next.row, index: next.index });
+      continue;
+    }
+    if (!sameLiveValue(old.row, next.row)) {
+      changes.push({ type: "update", row: next.row, previous: old.row, index: next.index });
     }
-    for (const [token, next] of current) {
-        const old = previous.get(token);
-        if (old === undefined) {
-            changes.push({ type: "insert", row: next.row, index: next.index });
-            continue;
-        }
-        if (!sameLiveValue(old.row, next.row)) {
-            changes.push({ type: "update", row: next.row, previous: old.row, index: next.index });
-        }
-        if (old.index !== next.index) {
-            changes.push({
-                type: "move",
-                key: next.row[key],
-                row: next.row,
-                from: old.index,
-                to: next.index,
-            });
-        }
+    if (old.index !== next.index) {
+      changes.push({
+        type: "move",
+        key: next.row[key],
+        row: next.row,
+        from: old.index,
+        to: next.index
+      });
     }
-    return changes;
+  }
+  return changes;
 }
-/** Keyed exact diffs over a typed live query, with optional bounded-window enforcement. */
-export class KeyedLiveQuery {
-    #source;
-    #key;
-    #maxRows;
-    #listeners = new Set();
-    #sourceUnsubscribe;
-    #rows = [];
-    #snapshot = { status: "loading", rows: [] };
-    #hasReadySnapshot = false;
-    #closed = false;
-    constructor(source, options) {
-        if (options.maxRows !== undefined &&
-            (!Number.isSafeInteger(options.maxRows) || options.maxRows <= 0)) {
-            throw new RangeError("Live query window maxRows must be a positive whole number");
-        }
-        this.#source = source;
-        this.#key = options.key;
-        this.#maxRows = options.maxRows;
+class KeyedLiveQuery {
+  #source;
+  #key;
+  #maxRows;
+  #listeners = /* @__PURE__ */ new Set();
+  #sourceUnsubscribe;
+  #rows = [];
+  #snapshot = { status: "loading", rows: [] };
+  #hasReadySnapshot = false;
+  #closed = false;
+  constructor(source, options) {
+    if (options.maxRows !== void 0 && (!Number.isSafeInteger(options.maxRows) || options.maxRows <= 0)) {
+      throw new RangeError("Live query window maxRows must be a positive whole number");
     }
-    getSnapshot = () => this.#snapshot;
-    subscribe = (listener) => {
-        if (this.#closed)
-            throw new Error("Keyed live query is closed");
-        const registered = () => listener();
-        this.#listeners.add(registered);
-        if (this.#listeners.size === 1) {
-            this.#sourceUnsubscribe = this.#source.subscribe(() => this.#accept(this.#source.getSnapshot()));
-            this.#accept(this.#source.getSnapshot());
-        }
-        let subscribed = true;
-        return () => {
-            if (!subscribed)
-                return;
-            subscribed = false;
-            this.#listeners.delete(registered);
-            if (this.#listeners.size === 0) {
-                this.#sourceUnsubscribe?.();
-                this.#sourceUnsubscribe = undefined;
-            }
-        };
-    };
-    async refresh() {
-        if (this.#closed)
-            throw new Error("Keyed live query is closed");
-        await this.#source.refresh();
-        this.#accept(this.#source.getSnapshot());
+    this.#source = source;
+    this.#key = options.key;
+    this.#maxRows = options.maxRows;
+  }
+  getSnapshot = () => this.#snapshot;
+  subscribe = (listener) => {
+    if (this.#closed)
+      throw new Error("Keyed live query is closed");
+    const registered = () => listener();
+    this.#listeners.add(registered);
+    if (this.#listeners.size === 1) {
+      this.#sourceUnsubscribe = this.#source.subscribe(() => this.#accept(this.#source.getSnapshot()));
+      this.#accept(this.#source.getSnapshot());
     }
-    close() {
-        if (this.#closed)
-            return;
-        this.#closed = true;
+    let subscribed = true;
+    return () => {
+      if (!subscribed)
+        return;
+      subscribed = false;
+      this.#listeners.delete(registered);
+      if (this.#listeners.size === 0) {
         this.#sourceUnsubscribe?.();
-        this.#sourceUnsubscribe = undefined;
-        this.#source.close();
-        this.#emit();
-        this.#listeners.clear();
+        this.#sourceUnsubscribe = void 0;
+      }
+    };
+  };
+  async refresh() {
+    if (this.#closed)
+      throw new Error("Keyed live query is closed");
+    await this.#source.refresh();
+    this.#accept(this.#source.getSnapshot());
+  }
+  close() {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    this.#sourceUnsubscribe?.();
+    this.#sourceUnsubscribe = void 0;
+    this.#source.close();
+    this.#emit();
+    this.#listeners.clear();
+  }
+  #accept(snapshot) {
+    if (this.#closed)
+      return;
+    if (snapshot.status === "loading") {
+      if (this.#snapshot.status === "loading")
+        return;
+      this.#snapshot = { status: "loading", rows: this.#rows };
+      this.#emit();
+      return;
+    }
+    if (snapshot.status === "error") {
+      this.#snapshot = {
+        status: "error",
+        rows: this.#rows,
+        error: snapshot.error,
+        version: snapshot.version
+      };
+      this.#emit();
+      return;
     }
-    #accept(snapshot) {
-        if (this.#closed)
-            return;
-        if (snapshot.status === "loading") {
-            if (this.#snapshot.status === "loading")
-                return;
-            this.#snapshot = { status: "loading", rows: this.#rows };
-            this.#emit();
-            return;
-        }
-        if (snapshot.status === "error") {
-            this.#snapshot = {
-                status: "error",
-                rows: this.#rows,
-                error: snapshot.error,
-                version: snapshot.version,
-            };
-            this.#emit();
-            return;
-        }
-        try {
-            if (this.#maxRows !== undefined && snapshot.rows.length > this.#maxRows) {
-                throw new RangeError(`Live query window returned ${String(snapshot.rows.length)} rows; maximum is ${String(this.#maxRows)}`);
-            }
-            const initial = !this.#hasReadySnapshot;
-            let changes;
-            if (initial) {
-                // Initial snapshots still validate uniqueness even though no previous index is needed.
-                indexRows(snapshot.rows, this.#key);
-                changes = snapshot.rows.map((row, index) => ({ type: "insert", row, index }));
-            }
-            else {
-                // diffRows builds each old/new key index exactly once and validates duplicates as it goes.
-                changes = diffRows(this.#rows, snapshot.rows, this.#key);
-            }
-            this.#rows = snapshot.rows;
-            this.#hasReadySnapshot = true;
-            this.#snapshot = {
-                status: "ready",
-                rows: snapshot.rows,
-                changes: Object.freeze(changes),
-                initial,
-                version: snapshot.version,
-            };
-            this.#emit();
-        }
-        catch (error) {
-            this.#snapshot = {
-                status: "error",
-                rows: this.#rows,
-                error,
-                version: snapshot.version,
-            };
-            this.#emit();
-        }
+    try {
+      if (this.#maxRows !== void 0 && snapshot.rows.length > this.#maxRows) {
+        throw new RangeError(`Live query window returned ${String(snapshot.rows.length)} rows; maximum is ${String(this.#maxRows)}`);
+      }
+      const initial = !this.#hasReadySnapshot;
+      let changes;
+      if (initial) {
+        indexRows(snapshot.rows, this.#key);
+        changes = snapshot.rows.map((row, index) => ({ type: "insert", row, index }));
+      } else {
+        changes = diffRows(this.#rows, snapshot.rows, this.#key);
+      }
+      this.#rows = snapshot.rows;
+      this.#hasReadySnapshot = true;
+      this.#snapshot = {
+        status: "ready",
+        rows: snapshot.rows,
+        changes: Object.freeze(changes),
+        initial,
+        version: snapshot.version
+      };
+      this.#emit();
+    } catch (error) {
+      this.#snapshot = {
+        status: "error",
+        rows: this.#rows,
+        error,
+        version: snapshot.version
+      };
+      this.#emit();
     }
-    #emit() {
-        for (const listener of [...this.#listeners]) {
-            try {
-                listener();
-            }
-            catch {
-                // Isolate external-store listeners.
-            }
-        }
+  }
+  #emit() {
+    for (const listener of [...this.#listeners]) {
+      try {
+        listener();
+      } catch {
+      }
     }
+  }
 }
+export {
+  KeyedLiveQuery
+};

package/dist/engine/live-api.js

@@ -1,4 +1,3 @@
-/** Optional typed and keyed live-query APIs. */
 export * from "./live.js";
 export * from "./typed-live.js";
 export * from "./keyed-live.js";

package/dist/engine/live-equal.js

@@ -1,42 +1,37 @@
 import { dateMilliseconds } from "../date-value.js";
-/**
- * Structural equality over live result values: dates by instant, arrays by element, objects by
- * own keys in insertion order. Shared by the typed live store's exact suppression and the keyed
- * live window's diffing; internal on purpose — live-api re-exports its modules wholesale, and
- * this helper is not part of the live API.
- */
-export function sameLiveValue(left, right) {
-    if (Object.is(left, right))
-        return true;
-    if (left instanceof Date || right instanceof Date) {
-        return (left instanceof Date &&
-            right instanceof Date &&
-            Object.is(dateMilliseconds(left), dateMilliseconds(right)));
-    }
-    if (Array.isArray(left) || Array.isArray(right)) {
-        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length)
-            return false;
-        for (let index = 0; index < left.length; index += 1) {
-            if (!sameLiveValue(left[index], right[index]))
-                return false;
-        }
-        return true;
-    }
-    if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) {
-        return false;
-    }
-    const leftRecord = left;
-    const rightRecord = right;
-    const leftKeys = Object.keys(leftRecord);
-    const rightKeys = Object.keys(rightRecord);
-    if (leftKeys.length !== rightKeys.length)
+function sameLiveValue(left, right) {
+  if (Object.is(left, right))
+    return true;
+  if (left instanceof Date || right instanceof Date) {
+    return left instanceof Date && right instanceof Date && Object.is(dateMilliseconds(left), dateMilliseconds(right));
+  }
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length)
+      return false;
+    for (let index = 0; index < left.length; index += 1) {
+      if (!sameLiveValue(left[index], right[index]))
         return false;
-    for (let index = 0; index < leftKeys.length; index += 1) {
-        const key = leftKeys[index];
-        if (key === undefined || key !== rightKeys[index])
-            return false;
-        if (!sameLiveValue(leftRecord[key], rightRecord[key]))
-            return false;
     }
     return true;
+  }
+  if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) {
+    return false;
+  }
+  const leftRecord = left;
+  const rightRecord = right;
+  const leftKeys = Object.keys(leftRecord);
+  const rightKeys = Object.keys(rightRecord);
+  if (leftKeys.length !== rightKeys.length)
+    return false;
+  for (let index = 0; index < leftKeys.length; index += 1) {
+    const key = leftKeys[index];
+    if (key === void 0 || key !== rightKeys[index])
+      return false;
+    if (!sameLiveValue(leftRecord[key], rightRecord[key]))
+      return false;
+  }
+  return true;
 }
+export {
+  sameLiveValue
+};