squirreling 0.9.4 → 0.10.0

package/README.md

@@ -91,6 +91,8 @@ Squirreling can work with any data source that implements the `AsyncDataSource`
 
 ```typescript
 interface AsyncDataSource {
+  numRows?: number
+  columns: string[]
   scan(options: ScanOptions): ScanResults
 }
 
@@ -113,6 +115,8 @@ The `scan()` method returns a `ScanResults` object containing a row stream and f
 
 ```typescript
 const customSource: AsyncDataSource = {
+  numRows: 1000000, // optional total row count for planning
+  columns: ['id', 'name', 'active'], // columns available in this source
   scan({ columns, where, limit, offset, signal }) {
     // Use hints to optimize your scan, or ignore them
     return {
@@ -147,7 +151,7 @@ Squirreling mostly follows the SQL standard. The following features are supporte
 - String: `CONCAT`, `SUBSTRING`, `REPLACE`, `LENGTH`, `UPPER`, `LOWER`, `TRIM`, `LEFT`, `RIGHT`, `INSTR`
 - Math: `ABS`, `SIGN`, `CEIL`, `FLOOR`, `ROUND`, `MOD`, `RAND`, `RANDOM`, `LN`, `LOG10`, `EXP`, `POWER`, `SQRT`
 - Trig: `SIN`, `COS`, `TAN`, `COT`, `ASIN`, `ACOS`, `ATAN`, `ATAN2`, `DEGREES`, `RADIANS`, `PI`
-- Date: `CURRENT_DATE`, `CURRENT_TIME`, `CURRENT_TIMESTAMP`, `INTERVAL`
+- Date: `CURRENT_DATE`, `CURRENT_TIME`, `CURRENT_TIMESTAMP`, `DATE_PART`, `DATE_TRUNC`, `EXTRACT`, `INTERVAL`
 - Json: `JSON_VALUE`, `JSON_QUERY`, `JSON_OBJECT`
 - Array: `ARRAY_LENGTH`, `ARRAY_POSITION`, `ARRAY_SORT`, `CARDINALITY`
 - Regex: `REGEXP_SUBSTR`, `REGEXP_REPLACE`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.9.4",
+  "version": "0.10.0",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",
@@ -37,7 +37,7 @@
     "test": "vitest run"
   },
   "devDependencies": {
-    "@types/node": "25.3.2",
+    "@types/node": "25.3.5",
     "@vitest/coverage-v8": "4.0.18",
     "eslint": "9.39.2",
     "eslint-plugin-jsdoc": "62.7.1",

package/src/backend/dataSource.js

@@ -6,27 +6,50 @@
  * Creates an async row accessor that wraps a plain JavaScript object
  *
  * @param {Record<string, SqlPrimitive>} obj - the plain object
+ * @param {string[]} columns - list of column names (keys in the object)
  * @returns {AsyncRow} a row accessor interface
  */
-export function asyncRow(obj) {
+export function asyncRow(obj, columns) {
   /** @type {AsyncCells} */
   const cells = {}
-  for (const [key, value] of Object.entries(obj)) {
-    cells[key] = () => Promise.resolve(value)
+  for (const key of columns) {
+    cells[key] = () => Promise.resolve(obj[key])
   }
-  return { columns: Object.keys(obj), cells }
+  return { columns, cells }
 }
 
 /**
  * Creates an async memory-backed data source from an array of plain objects
  *
- * @param {Record<string, SqlPrimitive>[]} data - array of plain objects
+ * @param {Object} options
+ * @param {Record<string, SqlPrimitive>[]} options.data - array of plain objects
+ * @param {string[]} [options.columns] - optional list of column names (if not provided, inferred from first row)
  * @returns {AsyncDataSource} an async data source interface
  */
-export function memorySource(data) {
+export function memorySource({ data, columns }) {
+  if (!columns) {
+    // Columns not provided, infer from data
+    if (!data.length) {
+      throw new Error('Unknown columns: data is empty and no columns provided')
+    }
+    columns = Object.keys(data[0])
+    // Check first 1000 rows for consistent columns
+    for (let i = 1; i < data.length && i < 1000; i++) {
+      const rowColumns = Object.keys(data[i])
+      const missing = columns.find(col => !rowColumns.includes(col))
+      if (missing) {
+        throw new Error(`Inconsistent data, column "${missing}" not found in row ${i}`)
+      }
+      const extra = rowColumns.find(col => !columns.includes(col))
+      if (extra) {
+        throw new Error(`Inconsistent data, unexpected column "${extra}" found in row ${i}`)
+      }
+    }
+  }
   return {
     numRows: data.length,
-    scan({ where, limit, offset, signal }) {
+    columns,
+    scan({ columns: scanColumns, where, limit, offset, signal }) {
       // Only apply offset and limit if no where clause
       const start = !where ? offset ?? 0 : 0
       const end = !where && limit !== undefined ? start + limit : data.length
@@ -34,7 +57,7 @@ export function memorySource(data) {
         rows: (async function* () {
           for (let i = start; i < end && i < data.length; i++) {
             if (signal?.aborted) break
-            yield asyncRow(data[i])
+            yield asyncRow(data[i], scanColumns ?? columns)
           }
         })(),
         appliedWhere: false,
@@ -53,6 +76,7 @@ export function cachedDataSource(source) {
   /** @type {Map<string, Promise<SqlPrimitive>>} */
   const cache = new Map()
   return {
+    ...source,
     scan(options) {
       // Does re-run the scan, but cache avoids re-computing expensive async cells
       // TODO: check cache first to avoid re-scanning when possible

package/src/execute/aggregates.js

@@ -91,7 +91,11 @@ export async function* executeHashAggregate(plan, context) {
 
     // Apply HAVING filter
     if (plan.having) {
-      const havingRow = { ...group[0], ...asyncRow }
+      /** @type {AsyncRow} */
+      const havingRow = {
+        columns: [...group[0].columns, ...asyncRow.columns],
+        cells: { ...group[0].cells, ...asyncRow.cells },
+      }
       const passes = await evaluateExpr({
         node: plan.having,
         row: havingRow,
@@ -125,7 +129,11 @@ export async function* executeScalarAggregate(plan, context) {
 
   // Apply HAVING filter
   if (plan.having) {
-    const havingRow = { ...group[0], ...asyncRow }
+    /** @type {AsyncRow} */
+    const havingRow = {
+      columns: [...group[0].columns, ...asyncRow.columns],
+      cells: { ...group[0].cells, ...asyncRow.cells },
+    }
     const passes = await evaluateExpr({
       node: plan.having,
       row: havingRow,

package/src/execute/execute.js

@@ -26,11 +26,11 @@ export async function* executeSql({ tables, query, functions, signal }) {
   // Normalize tables: convert arrays to AsyncDataSource
   /** @type {Record<string, AsyncDataSource>} */
   const normalizedTables = {}
-  for (const [name, source] of Object.entries(tables)) {
-    if (Array.isArray(source)) {
-      normalizedTables[name] = memorySource(source)
+  for (const [name, data] of Object.entries(tables)) {
+    if (Array.isArray(data)) {
+      normalizedTables[name] = memorySource({ data })
     } else {
-      normalizedTables[name] = source
+      normalizedTables[name] = data
     }
   }
 
@@ -95,16 +95,19 @@ export async function* executePlan({ plan, context }) {
  */
 async function* executeScan(plan, context) {
   const { tables, signal } = context
-  const dataSource = tables[plan.table]
-  if (dataSource === undefined) {
+  // check table
+  const table = tables[plan.table]
+  if (!table) {
     throw tableNotFoundError({ tableName: plan.table })
   }
-
-  const scanResult = dataSource.scan({ ...plan.hints, signal })
-  if (!scanResult.rows) {
-    throw new Error(`Data source "${plan.table}" scan() must return a ScanResults object with { rows, appliedWhere, appliedLimitOffset }`)
+  // check columns
+  const missingColumn = plan.hints.columns?.find(col => !table.columns.includes(col))
+  if (missingColumn) {
+    throw new Error(`Column "${missingColumn}" not found. Available columns: ${table.columns.join(', ') || '[]'}`)
   }
-  const { rows, appliedWhere, appliedLimitOffset } = scanResult
+
+  // do the scan
+  const { rows, appliedWhere, appliedLimitOffset } = table.scan({ ...plan.hints, signal })
 
   // Applied limit/offset without applied where is invalid
   const hasLimitOffset = plan.hints.limit !== undefined || plan.hints.offset // 0 offset is noop
@@ -135,17 +138,17 @@ async function* executeScan(plan, context) {
  * @yields {AsyncRow}
  */
 async function* executeCount(plan, { tables, signal }) {
-  const dataSource = tables[plan.table]
-  if (dataSource === undefined) {
+  const table = tables[plan.table]
+  if (!table) {
     throw tableNotFoundError({ tableName: plan.table })
   }
 
   // Use source numRows if available
-  let count = dataSource.numRows
-  if (dataSource.numRows === undefined) {
+  let count = table.numRows
+  if (table.numRows === undefined) {
     // Fall back to counting rows via scan
     count = 0
-    const { rows } = dataSource.scan({ signal })
+    const { rows } = table.scan({ signal })
     // eslint-disable-next-line no-unused-vars
     for await (const _ of rows) {
       if (signal?.aborted) return

package/src/execute/join.js

@@ -203,16 +203,16 @@ export async function* executeHashJoin(plan, context) {
 /**
  * Creates a NULL-filled row with the given column names
  *
- * @param {string[]} columnNames
+ * @param {string[]} columns
  * @returns {AsyncRow}
  */
-function createNullRow(columnNames) {
+function createNullRow(columns) {
   /** @type {AsyncCells} */
   const cells = {}
-  for (const col of columnNames) {
+  for (const col of columns) {
     cells[col] = () => Promise.resolve(null)
   }
-  return { columns: columnNames, cells }
+  return { columns, cells }
 }
 
 /**
@@ -234,6 +234,7 @@ function mergeRows(leftRow, rightRow, leftTable, rightTable) {
     // Skip already-prefixed keys (from previous joins)
     if (!key.includes('.')) {
       const alias = `${leftTable}.${key}`
+      columns.push(alias)
       cells[alias] = cell
     }
     // Also keep unqualified name for convenience
@@ -244,9 +245,9 @@ function mergeRows(leftRow, rightRow, leftTable, rightTable) {
   // Add right table columns with prefix
   for (const [key, cell] of Object.entries(rightRow.cells)) {
     if (!key.includes('.')) {
-      cells[`${rightTable}.${key}`] = cell
-    } else {
-      cells[key] = cell
+      const alias = `${rightTable}.${key}`
+      columns.push(alias)
+      cells[alias] = cell
     }
     // Unqualified name (overwrites if same name exists in left table)
     columns.push(key)

package/src/expression/date.js

@@ -40,6 +40,66 @@ export function applyIntervalToDate(dateVal, value, unit, op) {
   }
 }
 
+/**
+ * Truncate a date to the given precision
+ * @param {SqlPrimitive} precision - the unit to truncate to (year, month, day, hour, minute, second)
+ * @param {SqlPrimitive} dateVal - the date value to truncate
+ * @returns {Date | string | null}
+ */
+export function dateTrunc(precision, dateVal) {
+  if (precision == null || dateVal == null) return null
+  const date = toDate(dateVal)
+  if (date == null) return null
+
+  const unit = String(precision).toUpperCase()
+  if (unit === 'YEAR') {
+    date.setUTCMonth(0, 1)
+    date.setUTCHours(0, 0, 0, 0)
+  } else if (unit === 'MONTH') {
+    date.setUTCDate(1)
+    date.setUTCHours(0, 0, 0, 0)
+  } else if (unit === 'DAY') {
+    date.setUTCHours(0, 0, 0, 0)
+  } else if (unit === 'HOUR') {
+    date.setUTCMinutes(0, 0, 0)
+  } else if (unit === 'MINUTE') {
+    date.setUTCSeconds(0, 0)
+  } else if (unit === 'SECOND') {
+    date.setUTCMilliseconds(0)
+  }
+
+  // Return in same format as input
+  if (dateVal instanceof Date) return date
+  if (String(dateVal).includes('T')) {
+    return date.toISOString()
+  } else {
+    return date.toISOString().split('T')[0]
+  }
+}
+
+/**
+ * Extract a field from a date value
+ * @param {SqlPrimitive} field - the field to extract (YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, DOW, EPOCH)
+ * @param {SqlPrimitive} dateVal - the date value to extract from
+ * @returns {number | null}
+ */
+export function extractField(field, dateVal) {
+  if (field == null || dateVal == null) return null
+  const date = toDate(dateVal)
+  if (date == null) return null
+
+  const unit = String(field).toUpperCase()
+  if (unit === 'YEAR') return date.getUTCFullYear()
+  if (unit === 'MONTH') return date.getUTCMonth() + 1
+  if (unit === 'DAY') return date.getUTCDate()
+  if (unit === 'HOUR') return date.getUTCHours()
+  if (unit === 'MINUTE') return date.getUTCMinutes()
+  if (unit === 'SECOND') return date.getUTCSeconds()
+  if (unit === 'DOW') return date.getUTCDay()
+  if (unit === 'EPOCH') return date.getTime() / 1000
+  return null
+}
+
 /**
  * @param {SqlPrimitive} val
  * @returns {Date | null}

package/src/expression/evaluate.js

@@ -6,10 +6,10 @@ import { isAggregateFunc, isMathFunc, isRegexpFunc, isSpatialFunc, isStringFunc
 import { aggregateError, argValueError, castError } from '../validationErrors.js'
 import { derivedAlias } from './alias.js'
 import { applyBinaryOp } from './binary.js'
-import { applyIntervalToDate } from './date.js'
+import { applyIntervalToDate, dateTrunc, extractField } from './date.js'
 import { evaluateMathFunc } from './math.js'
 import { evaluateRegexpFunc } from './regexp.js'
-import { evaluateSpatialFunc } from './spatial.js'
+import { evaluateSpatialFunc } from '../spatial/spatial.js'
 import { evaluateStringFunc } from './strings.js'
 
 /**
@@ -47,7 +47,7 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
     // Unknown identifier
     throw columnNotFoundError({
       columnName: node.name,
-      availableColumns: Object.keys(row.cells),
+      availableColumns: row.columns,
       positionStart: node.positionStart,
       positionEnd: node.positionEnd,
       rowIndex,
@@ -225,7 +225,9 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
     }
 
     /** @type {SqlPrimitive[]} */
-    const args = await Promise.all(node.args.map(arg => evaluateExpr({ node: arg, row, rowIndex, rows, context })))
+    const args = node.args.length === 1
+      ? [await evaluateExpr({ node: node.args[0], row, rowIndex, rows, context })]
+      : await Promise.all(node.args.map(arg => evaluateExpr({ node: arg, row, rowIndex, rows, context })))
 
     if (isStringFunc(funcName)) {
       return evaluateStringFunc({
@@ -271,6 +273,14 @@ export async function evaluateExpr({ node, row, rowIndex, rows, context }) {
       return val1 == val2 ? null : val1
     }
 
+    if (funcName === 'DATE_TRUNC') {
+      return dateTrunc(args[0], args[1])
+    }
+
+    if (funcName === 'EXTRACT' || funcName === 'DATE_PART') {
+      return extractField(args[0], args[1])
+    }
+
     if (funcName === 'CURRENT_DATE') {
       return new Date().toISOString().split('T')[0]
     }

package/src/parse/expression.js

@@ -4,7 +4,7 @@ import {
   syntaxError,
   unknownFunctionError,
 } from '../parseErrors.js'
-import { isIntervalUnit, isKnownFunction } from '../validation.js'
+import { RESERVED_KEYWORDS, isExtractField, isIntervalUnit, isKnownFunction } from '../validation.js'
 import { parseComparison } from './comparison.js'
 import { parseFunctionCall } from './functions.js'
 import { parseSelectInternal } from './parse.js'
@@ -70,6 +70,36 @@ export function parsePrimary(state) {
       }
     }
 
+    // EXTRACT(field FROM expr)
+    if (tok.value === 'EXTRACT' && next.type === 'paren' && next.value === '(') {
+      consume(state) // EXTRACT
+      consume(state) // '('
+      const fieldTok = current(state)
+      const isValidType = fieldTok.type === 'keyword' || fieldTok.type === 'identifier'
+      if (!isValidType || !isExtractField(fieldTok.value)) {
+        throw syntaxError({
+          expected: 'extract field (YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, DOW, EPOCH)',
+          received: `"${fieldTok.value}"`,
+          positionStart: fieldTok.positionStart,
+          positionEnd: fieldTok.positionEnd,
+        })
+      }
+      consume(state) // field
+      expect(state, 'keyword', 'FROM')
+      const expr = parseExpression(state)
+      expect(state, 'paren', ')')
+      return {
+        type: 'function',
+        name: 'EXTRACT',
+        args: [
+          { type: 'literal', value: fieldTok.value, positionStart: fieldTok.positionStart, positionEnd: fieldTok.positionEnd },
+          expr,
+        ],
+        positionStart,
+        positionEnd: state.lastPos,
+      }
+    }
+
     // function call
     if (next.type === 'paren' && next.value === '(') {
       const funcName = tok.value
@@ -220,6 +250,17 @@ export function parsePrimary(state) {
     if (tok.value === 'INTERVAL') {
       return parseInterval(state)
     }
+
+    // Non-reserved keywords can be used as identifiers (e.g. column aliases)
+    if (!RESERVED_KEYWORDS.has(tok.value)) {
+      consume(state)
+      return {
+        type: 'identifier',
+        name: tok.originalValue ?? tok.value,
+        positionStart,
+        positionEnd: state.lastPos,
+      }
+    }
   }
 
   if (tok.type === 'operator' && tok.value === '-') {

package/src/plan/columns.js

@@ -39,22 +39,32 @@ export function extractColumns(select) {
   // Collect all identifiers from all clauses
   /** @type {Set<string>} */
   const identifiers = new Set()
+
+  // Collect ORDER BY identifiers, excluding SELECT aliases (their underlying
+  // columns are already collected from select.columns expressions above)
+  /** @type {Set<string>} */
+  const selectAliases = new Set()
+
   for (const col of select.columns) {
     if (col.kind === 'star' && col.table) {
       // SELECT table.* means all columns needed
       perTable.set(col.table, undefined)
     } else if (col.kind === 'derived') {
       collectColumnsFromExpr(col.expr, identifiers)
+      if (col.alias) {
+        selectAliases.add(col.alias)
+      }
     }
   }
   collectColumnsFromExpr(select.where, identifiers)
+
   for (const item of select.orderBy) {
-    collectColumnsFromExpr(item.expr, identifiers)
+    collectColumnsFromExpr(item.expr, identifiers, selectAliases)
   }
   for (const expr of select.groupBy) {
     collectColumnsFromExpr(expr, identifiers)
   }
-  collectColumnsFromExpr(select.having, identifiers)
+  collectColumnsFromExpr(select.having, identifiers, selectAliases)
   for (const join of select.joins) {
     collectColumnsFromExpr(join.on, identifiers)
   }
@@ -68,8 +78,13 @@ export function extractColumns(select) {
       const columnName = name.substring(dotIndex + 1)
       const set = perTable.get(tablePrefix)
       if (set) set.add(columnName)
+    } else if (aliases.length > 1) {
+      // Unqualified in a JOIN: can't disambiguate, request all columns from all tables
+      for (const alias of aliases) {
+        perTable.set(alias, undefined)
+      }
     } else {
-      // Unqualified: add to all tables (ambiguous)
+      // Unqualified, single table: add to that table
       for (const [, set] of perTable) {
         if (set) set.add(name)
       }
@@ -89,40 +104,43 @@ export function extractColumns(select) {
  *
  * @param {ExprNode} expr
  * @param {Set<string>} columns
+ * @param {Set<string>} [aliases] - aliases to exclude from columns
  */
-function collectColumnsFromExpr(expr, columns) {
+function collectColumnsFromExpr(expr, columns, aliases) {
   if (!expr) return
   if (expr.type === 'identifier') {
-    columns.add(expr.name)
+    if (!aliases?.has(expr.name)) {
+      columns.add(expr.name)
+    }
   } else if (expr.type === 'binary') {
-    collectColumnsFromExpr(expr.left, columns)
-    collectColumnsFromExpr(expr.right, columns)
+    collectColumnsFromExpr(expr.left, columns, aliases)
+    collectColumnsFromExpr(expr.right, columns, aliases)
   } else if (expr.type === 'unary') {
-    collectColumnsFromExpr(expr.argument, columns)
+    collectColumnsFromExpr(expr.argument, columns, aliases)
   } else if (expr.type === 'function') {
     for (const arg of expr.args) {
-      collectColumnsFromExpr(arg, columns)
+      collectColumnsFromExpr(arg, columns, aliases)
     }
-    collectColumnsFromExpr(expr.filter, columns)
+    collectColumnsFromExpr(expr.filter, columns, aliases)
   } else if (expr.type === 'cast') {
-    collectColumnsFromExpr(expr.expr, columns)
+    collectColumnsFromExpr(expr.expr, columns, aliases)
   } else if (expr.type === 'in valuelist') {
-    collectColumnsFromExpr(expr.expr, columns)
+    collectColumnsFromExpr(expr.expr, columns, aliases)
     for (const val of expr.values) {
-      collectColumnsFromExpr(val, columns)
+      collectColumnsFromExpr(val, columns, aliases)
     }
   } else if (expr.type === 'in') {
-    collectColumnsFromExpr(expr.expr, columns)
+    collectColumnsFromExpr(expr.expr, columns, aliases)
   } else if (expr.type === 'case') {
     if (expr.caseExpr) {
-      collectColumnsFromExpr(expr.caseExpr, columns)
+      collectColumnsFromExpr(expr.caseExpr, columns, aliases)
     }
     for (const when of expr.whenClauses) {
-      collectColumnsFromExpr(when.condition, columns)
-      collectColumnsFromExpr(when.result, columns)
+      collectColumnsFromExpr(when.condition, columns, aliases)
+      collectColumnsFromExpr(when.result, columns, aliases)
     }
     if (expr.elseResult) {
-      collectColumnsFromExpr(expr.elseResult, columns)
+      collectColumnsFromExpr(expr.elseResult, columns, aliases)
     }
   }
   // No columns: count(*), literal, interval, exists, not exists, subquery

package/src/spatial/bbox.js

@@ -0,0 +1,53 @@
+/**
+ * @import { BBox, SimpleGeometry } from './geometry.js'
+ */
+
+export const EPSILON = 1e-10
+export const EPSILON_SQ = EPSILON * EPSILON
+
+/** @type {WeakMap<SimpleGeometry, BBox>} */
+const bboxCache = new WeakMap()
+
+/**
+ * Test whether two bounding boxes overlap.
+ *
+ * @param {SimpleGeometry} a
+ * @param {SimpleGeometry} b
+ * @returns {boolean}
+ */
+export function bboxOverlap(a, b) {
+  const aBox = bbox(a)
+  const bBox = bbox(b)
+  return aBox.minX <= bBox.maxX && aBox.maxX >= bBox.minX && aBox.minY <= bBox.maxY && aBox.maxY >= bBox.minY
+}
+
+/**
+ * Compute the axis-aligned bounding box of a simple geometry.
+ * Results are cached per geometry object.
+ *
+ * @param {SimpleGeometry} geom
+ * @returns {BBox}
+ */
+function bbox(geom) {
+  let b = bboxCache.get(geom)
+  if (b) return b
+  if (geom.type === 'Point') {
+    const [x, y] = geom.coordinates
+    b = { minX: x, minY: y, maxX: x, maxY: y }
+  } else {
+    /** @type {number[][]} */
+    const points = geom.type === 'LineString'
+      ? geom.coordinates
+      : geom.coordinates[0] // outer ring
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity
+    for (const p of points) {
+      if (p[0] < minX) minX = p[0]
+      if (p[1] < minY) minY = p[1]
+      if (p[0] > maxX) maxX = p[0]
+      if (p[1] > maxY) maxY = p[1]
+    }
+    b = { minX, minY, maxX, maxY }
+  }
+  bboxCache.set(geom, b)
+  return b
+}

package/src/{expression/spatial.equality.js → spatial/equality.js}

@@ -2,14 +2,14 @@
  * @import { SimpleGeometry } from './geometry.js'
  */
 
-import { EPSILON, EPSILON_SQ, distSq } from './spatial.geometry.js'
+import { EPSILON, EPSILON_SQ, distSq } from './primitives.js'
 
 /**
  * @param {SimpleGeometry} a
  * @param {SimpleGeometry} b
  * @returns {boolean}
  */
-export function simpleGeomEqual(a, b) {
+export function geometryEqual(a, b) {
   if (a.type === 'Point' && b.type === 'Point') {
     return distSq(a.coordinates, b.coordinates) < EPSILON_SQ
   } else if (a.type === 'LineString' && b.type === 'LineString') {
@@ -25,7 +25,7 @@ export function simpleGeomEqual(a, b) {
  * @param {number[][]} b
  * @returns {boolean}
  */
-export function lineEqual(a, b) {
+function lineEqual(a, b) {
   if (a.length !== b.length) return false
   // Forward
   let forward = true
@@ -50,7 +50,7 @@ export function lineEqual(a, b) {
  * @param {number[][][]} b
  * @returns {boolean}
  */
-export function polygonEqual(a, b) {
+function polygonEqual(a, b) {
   if (a.length !== b.length) return false
   for (let i = 0; i < a.length; i++) {
     if (!ringsEqual(a[i], b[i])) return false
@@ -65,7 +65,7 @@ export function polygonEqual(a, b) {
  * @param {number[][]} ring2
  * @returns {boolean}
  */
-export function ringsEqual(ring1, ring2) {
+function ringsEqual(ring1, ring2) {
   if (ring1.length !== ring2.length) return false
   // Try every rotation
   const n = ring1.length - 1 // closed ring, last = first

package/src/{expression → spatial}/geometry.d.ts

@@ -15,6 +15,13 @@ export type Geometry =
  */
 export type SimpleGeometry = Point | LineString | Polygon
 
+export interface BBox {
+  minX: number
+  minY: number
+  maxX: number
+  maxY: number
+}
+
 /**
  * Boundary relationship between two geometries.
  */