@minnowdb/core 0.6.9 → 0.7.1

package/dist/block-format/types.js

@@ -1 +1,4 @@
-export const logicalTypes = ["boolean", "number", "string", "datetime"];
+const logicalTypes = ["boolean", "number", "string", "datetime"];
+export {
+  logicalTypes
+};

package/dist/block-format/unicode.js

@@ -1,46 +1,37 @@
-/**
- * Returns the exact UTF-8 byte length of a well-formed JavaScript string without allocating.
- *
- * UTF-8 cannot represent isolated UTF-16 surrogate code units. `TextEncoder` silently replaces
- * them with U+FFFD, which would make persistence lossy and can collapse distinct index keys.
- * Minnow rejects those strings instead, so every accepted string has one exact UTF-8 encoding
- * and round-trips byte-for-byte through the block format.
- */
-export function wellFormedUtf8ByteLength(value, context = "String value") {
-    return measureWellFormedUtf8(value, context);
+function wellFormedUtf8ByteLength(value, context = "String value") {
+  return measureWellFormedUtf8(value, context);
 }
-/** Rejects strings that cannot round-trip exactly through UTF-8 persistence. */
-export function assertWellFormedString(value, context = "String value") {
-    wellFormedUtf8ByteLength(value, context);
+function assertWellFormedString(value, context = "String value") {
+  wellFormedUtf8ByteLength(value, context);
 }
 function measureWellFormedUtf8(value, context) {
-    if (typeof value !== "string")
-        throw new TypeError(`${context} must be a string`);
-    let byteLength = 0;
-    for (let index = 0; index < value.length; index += 1) {
-        const code = value.charCodeAt(index);
-        if (code <= 0x7f) {
-            byteLength += 1;
-        }
-        else if (code <= 0x7ff) {
-            byteLength += 2;
-        }
-        else if (code >= 0xd800 && code <= 0xdbff) {
-            const low = index + 1 < value.length ? value.charCodeAt(index + 1) : 0;
-            if (low < 0xdc00 || low > 0xdfff)
-                throw unpairedSurrogate(context, index);
-            byteLength += 4;
-            index += 1;
-        }
-        else if (code >= 0xdc00 && code <= 0xdfff) {
-            throw unpairedSurrogate(context, index);
-        }
-        else {
-            byteLength += 3;
-        }
+  if (typeof value !== "string")
+    throw new TypeError(`${context} must be a string`);
+  let byteLength = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 127) {
+      byteLength += 1;
+    } else if (code <= 2047) {
+      byteLength += 2;
+    } else if (code >= 55296 && code <= 56319) {
+      const low = index + 1 < value.length ? value.charCodeAt(index + 1) : 0;
+      if (low < 56320 || low > 57343)
+        throw unpairedSurrogate(context, index);
+      byteLength += 4;
+      index += 1;
+    } else if (code >= 56320 && code <= 57343) {
+      throw unpairedSurrogate(context, index);
+    } else {
+      byteLength += 3;
     }
-    return byteLength;
+  }
+  return byteLength;
 }
 function unpairedSurrogate(context, index) {
-    return new TypeError(`${context} contains an unpaired surrogate at UTF-16 index ${String(index)}`);
+  return new TypeError(`${context} contains an unpaired surrogate at UTF-16 index ${String(index)}`);
 }
+export {
+  assertWellFormedString,
+  wellFormedUtf8ByteLength
+};

package/dist/date-value.d.ts

@@ -13,3 +13,8 @@ export declare function dateUtcMinutes(value: Date): number;
 export declare function dateUtcSeconds(value: Date): number;
 export declare function setDateUtcDate(value: Date, day: number): number;
 export declare function setDateUtcMonth(value: Date, month: number): number;
+/** Whole days since 1970-01-01 for an epoch-millisecond value (floored, so negatives work). */
+export declare function epochDays(milliseconds: number): number;
+export declare function civilFromDays(days: number): readonly [number, number, number];
+/** Days since 1970-01-01 for a civil date; month is 0-11 as in Date.UTC. */
+export declare function daysFromCivil(year: number, month: number, day: number): number;

package/dist/date-value.js

@@ -1,64 +1,94 @@
-// Capture the intrinsic once. A Date instance may shadow `getTime`; persistence, indexes, and
-// comparisons must all observe its internal [[DateValue]], not caller-controlled method code.
-// Capturing the intrinsic is the point: later Date.prototype mutations must not change values.
-// eslint-disable-next-line @typescript-eslint/unbound-method
 const intrinsicDateGetTime = Date.prototype.getTime;
-// eslint-disable-next-line @typescript-eslint/unbound-method -- See the getTime capture above.
 const intrinsicDateToISOString = Date.prototype.toISOString;
-// eslint-disable-next-line @typescript-eslint/unbound-method -- Captured for the same reason.
 const intrinsicDateGetUtcFullYear = Date.prototype.getUTCFullYear;
-// eslint-disable-next-line @typescript-eslint/unbound-method -- Captured for the same reason.
 const intrinsicDateGetUtcMonth = Date.prototype.getUTCMonth;
-// eslint-disable-next-line @typescript-eslint/unbound-method -- Captured for the same reason.
 const intrinsicDateGetUtcDate = Date.prototype.getUTCDate;
-// eslint-disable-next-line @typescript-eslint/unbound-method -- Captured for the same reason.
 const intrinsicDateGetUtcDay = Date.prototype.getUTCDay;
-// eslint-disable-next-line @typescript-eslint/unbound-method -- Captured for the same reason.
 const intrinsicDateGetUtcHours = Date.prototype.getUTCHours;
-// eslint-disable-next-line @typescript-eslint/unbound-method -- Captured for the same reason.
 const intrinsicDateGetUtcMinutes = Date.prototype.getUTCMinutes;
-// eslint-disable-next-line @typescript-eslint/unbound-method -- Captured for the same reason.
 const intrinsicDateGetUtcSeconds = Date.prototype.getUTCSeconds;
-// eslint-disable-next-line @typescript-eslint/unbound-method -- Captured for the same reason.
 const intrinsicDateSetUtcDate = Date.prototype.setUTCDate;
-// eslint-disable-next-line @typescript-eslint/unbound-method -- Captured for the same reason.
 const intrinsicDateSetUtcMonth = Date.prototype.setUTCMonth;
-/** Returns a Date's internal millisecond value without invoking an instance override. */
-export function dateMilliseconds(value) {
-    return intrinsicDateGetTime.call(value);
+function dateMilliseconds(value) {
+  return intrinsicDateGetTime.call(value);
 }
-/** Copies a Date by its internal value without invoking instance methods. */
-export function copyDate(value) {
-    return new Date(dateMilliseconds(value));
+function copyDate(value) {
+  return new Date(dateMilliseconds(value));
 }
-/** Formats a Date's internal value without invoking an instance override. */
-export function dateIsoString(value) {
-    return intrinsicDateToISOString.call(value);
+function dateIsoString(value) {
+  return intrinsicDateToISOString.call(value);
 }
-export function dateUtcFullYear(value) {
-    return intrinsicDateGetUtcFullYear.call(value);
+function dateUtcFullYear(value) {
+  return intrinsicDateGetUtcFullYear.call(value);
 }
-export function dateUtcMonth(value) {
-    return intrinsicDateGetUtcMonth.call(value);
+function dateUtcMonth(value) {
+  return intrinsicDateGetUtcMonth.call(value);
 }
-export function dateUtcDate(value) {
-    return intrinsicDateGetUtcDate.call(value);
+function dateUtcDate(value) {
+  return intrinsicDateGetUtcDate.call(value);
 }
-export function dateUtcDay(value) {
-    return intrinsicDateGetUtcDay.call(value);
+function dateUtcDay(value) {
+  return intrinsicDateGetUtcDay.call(value);
 }
-export function dateUtcHours(value) {
-    return intrinsicDateGetUtcHours.call(value);
+function dateUtcHours(value) {
+  return intrinsicDateGetUtcHours.call(value);
 }
-export function dateUtcMinutes(value) {
-    return intrinsicDateGetUtcMinutes.call(value);
+function dateUtcMinutes(value) {
+  return intrinsicDateGetUtcMinutes.call(value);
 }
-export function dateUtcSeconds(value) {
-    return intrinsicDateGetUtcSeconds.call(value);
+function dateUtcSeconds(value) {
+  return intrinsicDateGetUtcSeconds.call(value);
 }
-export function setDateUtcDate(value, day) {
-    return intrinsicDateSetUtcDate.call(value, day);
+function setDateUtcDate(value, day) {
+  return intrinsicDateSetUtcDate.call(value, day);
 }
-export function setDateUtcMonth(value, month) {
-    return intrinsicDateSetUtcMonth.call(value, month);
+function setDateUtcMonth(value, month) {
+  return intrinsicDateSetUtcMonth.call(value, month);
 }
+const MS_PER_DAY = 864e5;
+function epochDays(milliseconds) {
+  return Math.floor(milliseconds / MS_PER_DAY);
+}
+const civilScratch = [0, 0, 0];
+function civilFromDays(days) {
+  const z = days + 719468;
+  const era = Math.floor(z / 146097);
+  const dayOfEra = z - era * 146097;
+  const yearOfEra = (dayOfEra - Math.floor(dayOfEra / 1460) + Math.floor(dayOfEra / 36524) - Math.floor(dayOfEra / 146096)) / 365;
+  const yoe = Math.floor(yearOfEra);
+  const dayOfYear = dayOfEra - (365 * yoe + Math.floor(yoe / 4) - Math.floor(yoe / 100));
+  const mp = Math.floor((5 * dayOfYear + 2) / 153);
+  const day = dayOfYear - Math.floor((153 * mp + 2) / 5) + 1;
+  const month = mp < 10 ? mp + 2 : mp - 10;
+  const year = yoe + era * 400 + (month <= 1 ? 1 : 0);
+  civilScratch[0] = year;
+  civilScratch[1] = month;
+  civilScratch[2] = day;
+  return civilScratch;
+}
+function daysFromCivil(year, month, day) {
+  const y = month <= 1 ? year - 1 : year;
+  const era = Math.floor(y / 400);
+  const yoe = y - era * 400;
+  const mp = month > 1 ? month - 2 : month + 10;
+  const dayOfYear = Math.floor((153 * mp + 2) / 5) + day - 1;
+  const dayOfEra = yoe * 365 + Math.floor(yoe / 4) - Math.floor(yoe / 100) + dayOfYear;
+  return era * 146097 + dayOfEra - 719468;
+}
+export {
+  civilFromDays,
+  copyDate,
+  dateIsoString,
+  dateMilliseconds,
+  dateUtcDate,
+  dateUtcDay,
+  dateUtcFullYear,
+  dateUtcHours,
+  dateUtcMinutes,
+  dateUtcMonth,
+  dateUtcSeconds,
+  daysFromCivil,
+  epochDays,
+  setDateUtcDate,
+  setDateUtcMonth
+};

package/dist/engine/artifact-cache.js

@@ -1,123 +1,113 @@
-/**
- * Byte-bounded LRU for decoded blocks, vectors, derived results, and memoized query results.
- * Payloads are immutable by convention; callers own the byte estimates for their artifact type.
- *
- * Recency lives on an intrusive doubly-linked list rather than Map insertion order: a hit
- * relinks four pointers instead of deleting and re-inserting the key, which re-hashed the
- * long block-identity keys twice per touch and was the single hottest frame of a cached point
- * lookup.
- */
-export class ArtifactCache {
-    #limitBytes;
-    #entries = new Map();
-    /** Least recently used end of the recency list. */
-    #oldest;
-    /** Most recently used end of the recency list. */
-    #newest;
-    #usedBytes = 0;
-    #hits = 0;
-    #misses = 0;
-    #evictions = 0;
-    constructor(limitBytes) {
-        if (!Number.isSafeInteger(limitBytes) || limitBytes < 0) {
-            throw new RangeError("Prepare cache bytes must be a non-negative whole number");
-        }
-        this.#limitBytes = limitBytes;
+class ArtifactCache {
+  #limitBytes;
+  #entries = /* @__PURE__ */ new Map();
+  #oldest;
+  #newest;
+  #usedBytes = 0;
+  #hits = 0;
+  #misses = 0;
+  #evictions = 0;
+  constructor(limitBytes) {
+    if (!Number.isSafeInteger(limitBytes) || limitBytes < 0) {
+      throw new RangeError("Prepare cache bytes must be a non-negative whole number");
     }
-    get enabled() {
-        return this.#limitBytes > 0;
+    this.#limitBytes = limitBytes;
+  }
+  get enabled() {
+    return this.#limitBytes > 0;
+  }
+  #unlink(entry) {
+    if (entry.previous !== void 0)
+      entry.previous.next = entry.next;
+    else
+      this.#oldest = entry.next;
+    if (entry.next !== void 0)
+      entry.next.previous = entry.previous;
+    else
+      this.#newest = entry.previous;
+    entry.previous = void 0;
+    entry.next = void 0;
+  }
+  #appendNewest(entry) {
+    entry.previous = this.#newest;
+    entry.next = void 0;
+    if (this.#newest !== void 0)
+      this.#newest.next = entry;
+    this.#newest = entry;
+    this.#oldest ??= entry;
+  }
+  get(key) {
+    if (!this.enabled)
+      return void 0;
+    const entry = this.#entries.get(key);
+    if (entry === void 0) {
+      this.#misses += 1;
+      return void 0;
     }
-    #unlink(entry) {
-        if (entry.previous !== undefined)
-            entry.previous.next = entry.next;
-        else
-            this.#oldest = entry.next;
-        if (entry.next !== undefined)
-            entry.next.previous = entry.previous;
-        else
-            this.#newest = entry.previous;
-        entry.previous = undefined;
-        entry.next = undefined;
+    this.#hits += 1;
+    if (this.#newest !== entry) {
+      this.#unlink(entry);
+      this.#appendNewest(entry);
     }
-    #appendNewest(entry) {
-        entry.previous = this.#newest;
-        entry.next = undefined;
-        if (this.#newest !== undefined)
-            this.#newest.next = entry;
-        this.#newest = entry;
-        this.#oldest ??= entry;
+    return entry.payload;
+  }
+  put(key, payload, bytes) {
+    if (!this.enabled || bytes > this.#limitBytes)
+      return;
+    if (!Number.isSafeInteger(bytes) || bytes < 0) {
+      throw new RangeError("Artifact cache entry bytes must be a non-negative whole number");
     }
-    get(key) {
-        if (!this.enabled)
-            return undefined;
-        const entry = this.#entries.get(key);
-        if (entry === undefined) {
-            this.#misses += 1;
-            return undefined;
-        }
-        this.#hits += 1;
-        if (this.#newest !== entry) {
-            this.#unlink(entry);
-            this.#appendNewest(entry);
-        }
-        return entry.payload;
+    const existing = this.#entries.get(key);
+    if (existing !== void 0) {
+      this.#usedBytes -= existing.bytes;
+      existing.payload = payload;
+      existing.bytes = bytes;
+      this.#usedBytes += bytes;
+      if (this.#newest !== existing) {
+        this.#unlink(existing);
+        this.#appendNewest(existing);
+      }
+    } else {
+      const entry = {
+        key,
+        payload,
+        bytes,
+        previous: void 0,
+        next: void 0
+      };
+      this.#entries.set(key, entry);
+      this.#appendNewest(entry);
+      this.#usedBytes += bytes;
     }
-    put(key, payload, bytes) {
-        if (!this.enabled || bytes > this.#limitBytes)
-            return;
-        if (!Number.isSafeInteger(bytes) || bytes < 0) {
-            throw new RangeError("Artifact cache entry bytes must be a non-negative whole number");
-        }
-        const existing = this.#entries.get(key);
-        if (existing !== undefined) {
-            this.#usedBytes -= existing.bytes;
-            existing.payload = payload;
-            existing.bytes = bytes;
-            this.#usedBytes += bytes;
-            if (this.#newest !== existing) {
-                this.#unlink(existing);
-                this.#appendNewest(existing);
-            }
-        }
-        else {
-            const entry = {
-                key,
-                payload,
-                bytes,
-                previous: undefined,
-                next: undefined,
-            };
-            this.#entries.set(key, entry);
-            this.#appendNewest(entry);
-            this.#usedBytes += bytes;
-        }
-        let oldest = this.#oldest;
-        while (this.#usedBytes > this.#limitBytes && oldest !== undefined) {
-            const next = oldest.next;
-            if (oldest.key !== key) {
-                this.#unlink(oldest);
-                this.#entries.delete(oldest.key);
-                this.#usedBytes -= oldest.bytes;
-                this.#evictions += 1;
-            }
-            oldest = next;
-        }
-    }
-    /** Releases every retained payload while preserving lifetime counters for final diagnostics. */
-    clear() {
-        this.#entries.clear();
-        this.#oldest = undefined;
-        this.#newest = undefined;
-        this.#usedBytes = 0;
-    }
-    stats() {
-        return {
-            limitBytes: this.#limitBytes,
-            usedBytes: this.#usedBytes,
-            entries: this.#entries.size,
-            hits: this.#hits,
-            misses: this.#misses,
-            evictions: this.#evictions,
-        };
+    let oldest = this.#oldest;
+    while (this.#usedBytes > this.#limitBytes && oldest !== void 0) {
+      const next = oldest.next;
+      if (oldest.key !== key) {
+        this.#unlink(oldest);
+        this.#entries.delete(oldest.key);
+        this.#usedBytes -= oldest.bytes;
+        this.#evictions += 1;
+      }
+      oldest = next;
     }
+  }
+  clear() {
+    this.#entries.clear();
+    this.#oldest = void 0;
+    this.#newest = void 0;
+    this.#usedBytes = 0;
+  }
+  stats() {
+    return {
+      limitBytes: this.#limitBytes,
+      usedBytes: this.#usedBytes,
+      entries: this.#entries.size,
+      hits: this.#hits,
+      misses: this.#misses,
+      evictions: this.#evictions
+    };
+  }
 }
+export {
+  ArtifactCache
+};

package/dist/engine/batch.js

@@ -1,48 +1,40 @@
-/**
- * The input shapes the batch writes accept. Rows are the ordinary form — one object per row, the
- * same shape queries return. The columnar form (one array per column) is what the engine encodes,
- * so it stays available for bulk loads that already hold columns and want to skip the pivot.
- *
- * This module deliberately has no imports: the main-thread client normalizes here too, and must
- * not pull the engine in behind it.
- */
 function isColumnarBatch(input) {
-    return !Array.isArray(input);
+  return !Array.isArray(input);
 }
-/** Pivots rows into the engine's columnar form; a columnar batch passes straight through. */
-export function toColumnarBatch(input) {
-    if (isColumnarBatch(input))
-        return input;
-    if (input.length === 0)
-        throw new TypeError("A batch needs at least one row");
-    // One pass over the rows, discovering columns in first-seen order. Values and omission are
-    // separate so an explicit NULL can never accidentally invoke a default.
-    const columnsByName = new Map();
-    const omittedByName = new Map();
-    for (let index = 0; index < input.length; index += 1) {
-        const row = input[index];
-        if (row === undefined)
-            continue;
-        for (const name of Object.keys(row)) {
-            const value = row[name];
-            if (value === undefined)
-                continue;
-            let values = columnsByName.get(name);
-            if (values === undefined) {
-                values = new Array(input.length).fill(null);
-                columnsByName.set(name, values);
-                omittedByName.set(name, new Array(input.length).fill(true));
-            }
-            values[index] = value;
-            const omitted = omittedByName.get(name);
-            if (omitted !== undefined)
-                omitted[index] = false;
-        }
+function toColumnarBatch(input) {
+  if (isColumnarBatch(input))
+    return input;
+  if (input.length === 0)
+    throw new TypeError("A batch needs at least one row");
+  const columnsByName = /* @__PURE__ */ new Map();
+  const omittedByName = /* @__PURE__ */ new Map();
+  for (let index = 0; index < input.length; index += 1) {
+    const row = input[index];
+    if (row === void 0)
+      continue;
+    for (const name of Object.keys(row)) {
+      const value = row[name];
+      if (value === void 0)
+        continue;
+      let values = columnsByName.get(name);
+      if (values === void 0) {
+        values = new Array(input.length).fill(null);
+        columnsByName.set(name, values);
+        omittedByName.set(name, new Array(input.length).fill(true));
+      }
+      values[index] = value;
+      const omitted2 = omittedByName.get(name);
+      if (omitted2 !== void 0)
+        omitted2[index] = false;
     }
-    const omitted = Object.fromEntries([...omittedByName].filter(([, values]) => values.some(Boolean)));
-    return {
-        columns: Object.fromEntries(columnsByName),
-        ...(Object.keys(omitted).length === 0 ? {} : { omitted }),
-        rowCount: input.length,
-    };
+  }
+  const omitted = Object.fromEntries([...omittedByName].filter(([, values]) => values.some(Boolean)));
+  return {
+    columns: Object.fromEntries(columnsByName),
+    ...Object.keys(omitted).length === 0 ? {} : { omitted },
+    rowCount: input.length
+  };
 }
+export {
+  toColumnarBatch
+};