@mintlify/common 1.0.1309 → 1.0.1311

package/dist/databases/formula/types.d.ts

@@ -0,0 +1,26 @@
+import type { FormulaError } from './errors.js';
+export type FormulaScalar = number | string | boolean | Date | null;
+export type FormulaValue = FormulaScalar | FormulaError;
+export type FormulaType = 'number' | 'string' | 'boolean' | 'date' | 'any';
+export type FormulaRow = Readonly<Record<string, unknown>>;
+export type FormulaOption = string | {
+    id: string;
+    label: string;
+};
+export type FormulaColumn = {
+    id: string;
+    name: string;
+    type: string;
+    options?: readonly FormulaOption[];
+    config?: {
+        expression?: string;
+    } | null;
+};
+export declare const NUMBER = 1;
+export declare const STRING = 2;
+export declare const BOOLEAN = 4;
+export declare const DATE = 8;
+export declare const ANY: number;
+export type TypeSet = number;
+export declare const typeName: (types: TypeSet) => FormulaType;
+export declare const describeTypes: (types: TypeSet) => string;

package/dist/databases/formula/types.js

@@ -0,0 +1,27 @@
+export const NUMBER = 1;
+export const STRING = 2;
+export const BOOLEAN = 4;
+export const DATE = 8;
+export const ANY = NUMBER | STRING | BOOLEAN | DATE;
+export const typeName = (types) => {
+    if (types === NUMBER)
+        return 'number';
+    if (types === STRING)
+        return 'string';
+    if (types === BOOLEAN)
+        return 'boolean';
+    if (types === DATE)
+        return 'date';
+    return 'any';
+};
+export const describeTypes = (types) => {
+    const names = [
+        [NUMBER, 'number'],
+        [STRING, 'text'],
+        [BOOLEAN, 'boolean'],
+        [DATE, 'date'],
+    ]
+        .filter(([bit]) => types & bit)
+        .map(([, name]) => name);
+    return names.length === 4 ? 'any value' : names.join(' or ');
+};

package/dist/databases/formula/values.d.ts

@@ -0,0 +1,8 @@
+import type { OptionMaps } from './schema.js';
+import type { FormulaColumn, FormulaScalar, FormulaValue } from './types.js';
+export declare const formatFormulaValue: (value: FormulaValue) => string;
+export declare const isEmptyScalar: (value: FormulaScalar) => value is "" | null;
+export declare const parseDateValue: (raw: unknown) => Date | null;
+export declare const optionIds: (raw: unknown) => string[];
+export type CellReader = (raw: unknown) => FormulaScalar;
+export declare const cellReader: (column: FormulaColumn, options: OptionMaps) => CellReader;

package/dist/databases/formula/values.js

@@ -0,0 +1,100 @@
+import { normalizeDate } from '../query/values.js';
+import { isFormulaError } from './errors.js';
+const isValidDate = (value) => value instanceof Date && !Number.isNaN(value.getTime());
+const formatNumber = (value) => {
+    if (!Number.isFinite(value))
+        return String(value);
+    const rounded = Math.abs(value) < 1e21 ? Number(value.toFixed(10)) : value;
+    return String(rounded === 0 && value !== 0 ? Number(value.toPrecision(10)) : rounded);
+};
+const formatDate = (value) => {
+    if (!isValidDate(value))
+        return '';
+    const iso = value.toISOString();
+    return iso.endsWith('T00:00:00.000Z') ? iso.slice(0, 10) : iso;
+};
+export const formatFormulaValue = (value) => {
+    if (value === null)
+        return '';
+    if (isFormulaError(value))
+        return 'Error';
+    if (value instanceof Date)
+        return formatDate(value);
+    if (typeof value === 'number')
+        return formatNumber(value);
+    return String(value);
+};
+export const isEmptyScalar = (value) => value === null || value === '';
+export const parseDateValue = (raw) => {
+    if (raw instanceof Date)
+        return isValidDate(raw) ? raw : null;
+    const normalized = normalizeDate(raw);
+    return normalized === null ? null : new Date(normalized);
+};
+const DATE_CACHE_LIMIT = 10000;
+const cachedDates = () => {
+    const cache = new Map();
+    return (raw) => {
+        if (typeof raw !== 'string')
+            return parseDateValue(raw);
+        const known = cache.get(raw);
+        if (known !== undefined)
+            return known;
+        const parsed = parseDateValue(raw);
+        if (cache.size >= DATE_CACHE_LIMIT)
+            cache.clear();
+        cache.set(raw, parsed);
+        return parsed;
+    };
+};
+const toText = (raw) => typeof raw === 'string'
+    ? raw
+    : typeof raw === 'number' || typeof raw === 'boolean'
+        ? String(raw)
+        : null;
+const toJson = (raw) => {
+    var _a;
+    if (raw === null || raw === undefined)
+        return null;
+    try {
+        return (_a = JSON.stringify(raw)) !== null && _a !== void 0 ? _a : null;
+    }
+    catch (_b) {
+        return null;
+    }
+};
+export const optionIds = (raw) => Array.isArray(raw) ? raw.filter((item) => typeof item === 'string') : [];
+export const cellReader = (column, options) => {
+    switch (column.type) {
+        case 'number':
+            return (raw) => (typeof raw === 'number' && Number.isFinite(raw) ? raw : null);
+        case 'boolean':
+            return (raw) => (typeof raw === 'boolean' ? raw : null);
+        case 'date':
+            return cachedDates();
+        case 'select':
+            return (raw) => { var _a; return (typeof raw === 'string' ? ((_a = options.labelById.get(raw)) !== null && _a !== void 0 ? _a : raw) : null); };
+        case 'multi_select':
+            return (raw) => optionIds(raw)
+                .map((id) => { var _a; return (_a = options.labelById.get(id)) !== null && _a !== void 0 ? _a : id; })
+                .join(', ');
+        case 'json':
+            return toJson;
+        case 'text':
+        case 'url':
+        case 'email':
+            return toText;
+        default:
+            return (raw) => raw instanceof Date
+                ? isValidDate(raw)
+                    ? raw
+                    : null
+                : typeof raw === 'number'
+                    ? Number.isFinite(raw)
+                        ? raw
+                        : null
+                    : typeof raw === 'string' || typeof raw === 'boolean'
+                        ? raw
+                        : null;
+    }
+};

package/dist/databases/query/evaluate.d.ts

@@ -0,0 +1,25 @@
+import { type QueryColumn, type QueryExpr, type QueryRequest, type QueryRow } from './types.js';
+import { type QueryError } from './validate.js';
+export type { QueryError } from './validate.js';
+export type QueryResult = {
+    ids: string[];
+    total: number;
+    aggregates?: Record<string, number | null>;
+};
+export type RowPredicate = (row: QueryRow) => boolean;
+export declare const compensatedSum: (values: readonly number[]) => number;
+export declare const measureQuery: (root: QueryExpr) => {
+    depth: number;
+    nodes: number;
+};
+export declare const compileQueryFilter: (filter: QueryExpr, columns: readonly QueryColumn[]) => {
+    test: RowPredicate;
+} | {
+    error: QueryError;
+};
+export type EvaluateQueryOptions = {
+    ids?: boolean;
+};
+export declare const evaluateQuery: (request: QueryRequest, rows: readonly QueryRow[], columns: readonly QueryColumn[], options?: EvaluateQueryOptions) => QueryResult | {
+    error: QueryError;
+};

package/dist/databases/query/evaluate.js

@@ -0,0 +1,481 @@
+import { CLIENT_ONLY, QUERY_LIMITS, } from './types.js';
+import { validateQueryExpr, validateQueryRequest } from './validate.js';
+import { asciiLower, compareCodePoints, normalizeDate } from './values.js';
+const KINDS = {
+    text: 'text',
+    url: 'text',
+    email: 'text',
+    number: 'number',
+    boolean: 'boolean',
+    date: 'date',
+    select: 'select',
+    multi_select: 'multi_select',
+};
+const kindOf = (type) => (Object.hasOwn(KINDS, type) ? KINDS[type] : undefined);
+const CLIENT_ONLY_TYPES = new Set(['formula']);
+const MIRRORED = new Map([
+    ['eq', 'eq'],
+    ['ne', 'ne'],
+    ['lt', 'gt'],
+    ['lte', 'gte'],
+    ['gt', 'lt'],
+    ['gte', 'lte'],
+]);
+const NEVER = () => false;
+const ALWAYS = () => true;
+const readScalar = (kind, raw) => {
+    switch (kind) {
+        case 'number':
+            return typeof raw === 'number' && Number.isFinite(raw) ? raw : null;
+        case 'boolean':
+            return typeof raw === 'boolean' ? (raw ? 1 : 0) : null;
+        case 'date':
+            return normalizeDate(raw);
+        case 'select':
+            return typeof raw === 'string' && raw !== '' ? raw : null;
+        case 'text':
+            return typeof raw === 'string'
+                ? raw
+                : (typeof raw === 'number' && Number.isFinite(raw)) || typeof raw === 'boolean'
+                    ? String(raw)
+                    : null;
+        default:
+            return typeof raw === 'string' ? raw : null;
+    }
+};
+const elementsOf = (row, id) => {
+    const raw = row.columns[id];
+    return Array.isArray(raw) ? raw.filter((item) => typeof item === 'string') : [];
+};
+const compareScalars = (a, b) => typeof a === 'number' && typeof b === 'number'
+    ? Math.sign(a - b)
+    : compareCodePoints(String(a), String(b));
+const holds = (op, order) => {
+    switch (op) {
+        case 'eq':
+            return order === 0;
+        case 'ne':
+            return order !== 0;
+        case 'lt':
+            return order < 0;
+        case 'lte':
+            return order <= 0;
+        case 'gt':
+            return order > 0;
+        case 'gte':
+            return order >= 0;
+    }
+};
+export const compensatedSum = (values) => {
+    let sum = 0;
+    let compensation = 0;
+    for (const value of values) {
+        const next = sum + value;
+        compensation += Math.abs(sum) >= Math.abs(value) ? sum - next + value : value - next + sum;
+        sum = next;
+    }
+    return sum + compensation;
+};
+const isFilledText = (value) => typeof value === 'string' && value !== '';
+const emptyOf = (ref) => ref.kind === 'multi_select'
+    ? (row) => elementsOf(row, ref.id).length === 0
+    : (row) => {
+        const value = ref.read(row);
+        return value === null || (ref.kind === 'text' && value === '');
+    };
+const filledOf = (ref) => {
+    const empty = emptyOf(ref);
+    return (row) => !empty(row);
+};
+export const measureQuery = (root) => {
+    let depth = 0;
+    let nodes = 1;
+    const pending = [{ node: root, level: 1 }];
+    for (let next = pending.pop(); next && nodes <= QUERY_LIMITS.nodes; next = pending.pop()) {
+        depth = Math.max(depth, next.level);
+        if (depth > QUERY_LIMITS.depth)
+            break;
+        const { node } = next;
+        const children = node.kind === 'and' || node.kind === 'or'
+            ? node.args.slice(0, QUERY_LIMITS.nodes + 1 - nodes)
+            : node.kind === 'not' || node.kind === 'isEmpty' || node.kind === 'in'
+                ? [node.arg]
+                : node.kind === 'compare' || node.kind === 'text'
+                    ? [node.left, node.right]
+                    : [];
+        for (const child of children) {
+            if (++nodes > QUERY_LIMITS.nodes)
+                break;
+            pending.push({ node: child, level: next.level + 1 });
+        }
+    }
+    return { depth, nodes };
+};
+class Compiler {
+    constructor(columns) {
+        this.columns = columns;
+        this.fields = {};
+        this.clientOnly = false;
+    }
+    condition(expr, path) {
+        switch (expr.kind) {
+            case 'and':
+            case 'or': {
+                const args = expr.args.map((arg, index) => this.condition(arg, `${path}.args.${index}`));
+                if (expr.kind === 'and')
+                    return (row) => args.every((arg) => arg(row));
+                return (row) => args.some((arg) => arg(row));
+            }
+            case 'not': {
+                const arg = this.condition(expr.arg, `${path}.arg`);
+                return (row) => !arg(row);
+            }
+            case 'compare':
+                return this.compare(expr.op, expr.left, expr.right, path);
+            case 'text':
+                return this.text(expr, path);
+            case 'isEmpty': {
+                const ref = this.operand(expr.arg, `${path}.arg`);
+                return ref ? emptyOf(ref) : NEVER;
+            }
+            case 'in':
+                return this.in(expr, path);
+            case 'column': {
+                const ref = this.ref(expr.id, path);
+                if (!ref)
+                    return NEVER;
+                if (ref.kind !== 'boolean')
+                    return this.fail(path, 'only checkbox columns are conditions');
+                return (row) => ref.read(row) === 1;
+            }
+            case 'literal':
+                if (typeof expr.value !== 'boolean')
+                    return this.fail(path, 'expected a condition');
+                return expr.value ? ALWAYS : NEVER;
+        }
+    }
+    sortKeys(sort) {
+        if (!(sort === null || sort === void 0 ? void 0 : sort.length))
+            return [];
+        if (sort.length > QUERY_LIMITS.sortKeys) {
+            this.fail('sort', `at most ${QUERY_LIMITS.sortKeys} sort keys`);
+        }
+        const seen = new Set();
+        return sort.map(({ columnId }, index) => {
+            const path = `sort.${index}.columnId`;
+            const ref = this.ref(columnId, path);
+            if (seen.has(columnId))
+                this.fail(path, 'column is already sorted');
+            seen.add(columnId);
+            if (!ref)
+                return () => null;
+            if (ref.kind === 'multi_select')
+                this.fail(path, 'multi_select columns cannot be sorted');
+            return ref.kind === 'text'
+                ? (row) => {
+                    const value = ref.read(row);
+                    return value === '' ? null : value;
+                }
+                : ref.read;
+        });
+    }
+    aggregate({ columnId, fn }, path) {
+        const ref = this.ref(columnId, `${path}.columnId`);
+        if (!ref)
+            return () => null;
+        switch (fn) {
+            case 'count':
+                return (rows) => rows.length;
+            case 'count_empty': {
+                const empty = emptyOf(ref);
+                return (rows) => rows.filter(empty).length;
+            }
+            case 'count_filled': {
+                const filled = filledOf(ref);
+                return (rows) => rows.filter(filled).length;
+            }
+            default: {
+                if (ref.kind !== 'number') {
+                    this.fail(`${path}.fn`, `${fn} needs a number column`);
+                    return () => null;
+                }
+                return (rows) => {
+                    const numbers = rows
+                        .map(ref.read)
+                        .filter((value) => typeof value === 'number');
+                    if (fn === 'sum')
+                        return compensatedSum(numbers);
+                    if (!numbers.length)
+                        return null;
+                    if (fn === 'avg')
+                        return compensatedSum(numbers) / numbers.length;
+                    let extreme = numbers[0];
+                    for (const value of numbers) {
+                        if (fn === 'min' ? value < extreme : value > extreme)
+                            extreme = value;
+                    }
+                    return extreme;
+                };
+            }
+        }
+    }
+    error() {
+        if (this.clientOnly)
+            return { message: CLIENT_ONLY, fields: this.fields };
+        return Object.keys(this.fields).length
+            ? { message: 'query is invalid', fields: this.fields }
+            : null;
+    }
+    fail(path, message) {
+        var _a;
+        var _b;
+        (_a = (_b = this.fields)[path]) !== null && _a !== void 0 ? _a : (_b[path] = message);
+        return NEVER;
+    }
+    ref(columnId, path) {
+        const column = this.columns.get(columnId);
+        if (!column) {
+            this.fail(path, 'unknown column');
+            return undefined;
+        }
+        if (CLIENT_ONLY_TYPES.has(column.type)) {
+            this.clientOnly = true;
+            this.fail(path, CLIENT_ONLY);
+            return undefined;
+        }
+        const kind = kindOf(column.type);
+        if (!kind) {
+            this.fail(path, `${column.type} columns cannot be queried`);
+            return undefined;
+        }
+        return {
+            id: column.id,
+            type: column.type,
+            kind,
+            read: (row) => readScalar(kind, row.columns[column.id]),
+        };
+    }
+    operand(expr, path) {
+        if (expr.kind === 'column')
+            return this.ref(expr.id, path);
+        this.fail(path, 'expected a column');
+        return undefined;
+    }
+    compare(op, left, right, path, sides = { left: `${path}.left`, right: `${path}.right` }) {
+        var _a;
+        if (left.kind !== 'column' && right.kind === 'column') {
+            return this.compare((_a = MIRRORED.get(op)) !== null && _a !== void 0 ? _a : op, right, left, path, {
+                left: sides.right,
+                right: sides.left,
+            });
+        }
+        if (left.kind !== 'column')
+            return this.fail(path, 'compare needs a column');
+        const ref = this.ref(left.id, sides.left);
+        if (right.kind === 'column') {
+            const other = this.ref(right.id, sides.right);
+            return ref && other ? this.compareColumns(op, ref, other, path) : NEVER;
+        }
+        if (right.kind !== 'literal')
+            return this.fail(sides.right, 'expected a column or a value');
+        if (!ref)
+            return NEVER;
+        if ((ref.kind === 'multi_select' || ref.kind === 'boolean') && op !== 'eq' && op !== 'ne') {
+            return this.fail(path, `${ref.type} columns only support eq and ne`);
+        }
+        const value = this.literal(ref, right.value, sides.right);
+        if (value === undefined)
+            return NEVER;
+        if (ref.kind === 'multi_select') {
+            const has = (row) => elementsOf(row, ref.id).includes(String(value));
+            return op === 'eq' ? has : (row) => !has(row);
+        }
+        const guarded = ref.kind === 'text' && (op === 'ne' || op === 'lt' || op === 'lte');
+        return (row) => {
+            const cell = ref.read(row);
+            if (cell === null || (guarded && !isFilledText(cell)))
+                return op === 'ne';
+            return holds(op, compareScalars(cell, value));
+        };
+    }
+    compareColumns(op, a, b, path) {
+        if (a.kind === 'multi_select' || b.kind === 'multi_select' || a.kind !== b.kind) {
+            return this.fail(path, `${a.type} and ${b.type} columns cannot be compared`);
+        }
+        if (a.kind === 'boolean' && op !== 'eq' && op !== 'ne') {
+            return this.fail(path, 'boolean columns only support eq and ne');
+        }
+        const text = a.kind === 'text';
+        return (row) => {
+            const left = a.read(row);
+            const right = b.read(row);
+            if (left === null || right === null)
+                return op === 'ne';
+            if (text && (!isFilledText(left) || !isFilledText(right)))
+                return op === 'ne';
+            return holds(op, compareScalars(left, right));
+        };
+    }
+    text(expr, path) {
+        const ref = this.operand(expr.left, `${path}.left`);
+        const needle = expr.right.kind === 'literal' ? expr.right.value : undefined;
+        if (needle !== null && typeof needle !== 'string') {
+            return this.fail(`${path}.right`, 'expected a string');
+        }
+        if (!ref)
+            return NEVER;
+        if (ref.kind !== 'text')
+            return this.fail(`${path}.left`, `${ref.type} columns are not text`);
+        if (!needle)
+            return NEVER;
+        const lowered = asciiLower(needle);
+        const match = expr.op === 'contains'
+            ? (value) => value.includes(lowered)
+            : expr.op === 'startsWith'
+                ? (value) => value.startsWith(lowered)
+                : (value) => value.endsWith(lowered);
+        return (row) => {
+            const cell = ref.read(row);
+            return typeof cell === 'string' && match(asciiLower(cell));
+        };
+    }
+    in(expr, path) {
+        const ref = this.operand(expr.arg, `${path}.arg`);
+        if (expr.values.length > QUERY_LIMITS.inValues) {
+            return this.fail(`${path}.values`, `at most ${QUERY_LIMITS.inValues} values`);
+        }
+        if (!ref)
+            return NEVER;
+        const values = expr.values.flatMap((value, index) => {
+            const bound = this.literal(ref, value, `${path}.values.${index}`);
+            return bound === undefined ? [] : [bound];
+        });
+        if (!values.length)
+            return NEVER;
+        const set = new Set(values);
+        if (ref.kind === 'multi_select') {
+            return (row) => elementsOf(row, ref.id).some((item) => set.has(item));
+        }
+        return (row) => {
+            const cell = ref.read(row);
+            return cell !== null && set.has(cell);
+        };
+    }
+    literal(ref, value, path) {
+        if (value === null || value === '')
+            return undefined;
+        if (typeof value === 'string' && value.length > QUERY_LIMITS.literalLength) {
+            this.fail(path, `at most ${QUERY_LIMITS.literalLength} characters`);
+            return undefined;
+        }
+        switch (ref.kind) {
+            case 'number':
+                if (typeof value === 'number' && Number.isFinite(value))
+                    return value;
+                this.fail(path, 'expected a number');
+                return undefined;
+            case 'boolean':
+                if (typeof value === 'boolean')
+                    return value ? 1 : 0;
+                this.fail(path, 'expected true or false');
+                return undefined;
+            case 'date': {
+                const normalized = normalizeDate(value);
+                if (normalized !== null)
+                    return normalized;
+                this.fail(path, 'expected an ISO 8601 date string');
+                return undefined;
+            }
+            default:
+                if (typeof value === 'string')
+                    return value;
+                this.fail(path, 'expected a string');
+                return undefined;
+        }
+    }
+}
+const UNEXPECTED = {
+    message: 'query is invalid',
+    fields: { request: 'could not be evaluated' },
+};
+const columnMap = (columns) => new Map(columns.map((column) => [column.id, column]));
+export const compileQueryFilter = (filter, columns) => {
+    const invalid = validateQueryExpr(filter);
+    if (invalid)
+        return { error: invalid };
+    try {
+        const compiler = new Compiler(columnMap(columns));
+        const test = compiler.condition(filter, 'filter');
+        const error = compiler.error();
+        return error ? { error } : { test };
+    }
+    catch (_a) {
+        return { error: UNEXPECTED };
+    }
+};
+const byKeys = (sort) => (a, b) => {
+    var _a;
+    var _b;
+    if (!a.keys.length) {
+        const order = Math.sign(a.created - b.created);
+        if (order)
+            return order;
+    }
+    for (const [index, left] of a.keys.entries()) {
+        const right = (_b = b.keys[index]) !== null && _b !== void 0 ? _b : null;
+        if (left === null || right === null) {
+            if (left !== right)
+                return left === null ? 1 : -1;
+            continue;
+        }
+        const order = compareScalars(left, right);
+        if (order)
+            return ((_a = sort === null || sort === void 0 ? void 0 : sort[index]) === null || _a === void 0 ? void 0 : _a.direction) === 'desc' ? -order : order;
+    }
+    return compareCodePoints(a.row.id, b.row.id);
+};
+const ordered = (rows, keys, sort) => rows
+    .map((row) => ({
+    row,
+    keys: keys.map((key) => key(row)),
+    created: keys.length ? 0 : Date.parse(row.createdAt),
+}))
+    .sort(byKeys(sort))
+    .map(({ row }) => row);
+export const evaluateQuery = (request, rows, columns, options = {}) => {
+    const invalid = validateQueryRequest(request);
+    if (invalid)
+        return { error: invalid };
+    try {
+        return run(request, rows, columns, options);
+    }
+    catch (_a) {
+        return { error: UNEXPECTED };
+    }
+};
+const run = (request, rows, columns, options) => {
+    var _a, _b;
+    var _c;
+    const compiler = new Compiler(columnMap(columns));
+    const test = request.filter ? compiler.condition(request.filter, 'filter') : ALWAYS;
+    const keys = compiler.sortKeys(request.sort);
+    if (((_c = (_a = request.aggregates) === null || _a === void 0 ? void 0 : _a.length) !== null && _c !== void 0 ? _c : 0) > QUERY_LIMITS.aggregates) {
+        compiler.fail('aggregates', `at most ${QUERY_LIMITS.aggregates} aggregates`);
+    }
+    const aggregates = new Map();
+    (_b = request.aggregates) === null || _b === void 0 ? void 0 : _b.forEach((aggregate, index) => {
+        const key = `${aggregate.columnId}:${aggregate.fn}`;
+        if (!aggregates.has(key))
+            aggregates.set(key, compiler.aggregate(aggregate, `aggregates.${index}`));
+    });
+    const error = compiler.error();
+    if (error)
+        return { error };
+    const filtered = rows.filter(test);
+    const matched = options.ids === false ? filtered : ordered(filtered, keys, request.sort);
+    return Object.assign({ ids: options.ids === false ? [] : matched.map((row) => row.id), total: matched.length }, (aggregates.size
+        ? {
+            aggregates: Object.fromEntries([...aggregates].map(([key, compute]) => [key, compute(matched)])),
+        }
+        : {}));
+};

package/dist/databases/query/index.d.ts

@@ -0,0 +1,4 @@
+export { compensatedSum, compileQueryFilter, evaluateQuery, type EvaluateQueryOptions, measureQuery, type QueryError, type QueryResult, type RowPredicate, } from './evaluate.js';
+export * from './types.js';
+export { isValidQueryRequest, validateQueryExpr, validateQueryRequest } from './validate.js';
+export { asciiLower, compareCodePoints, isEmptyValue, normalizeDate } from './values.js';

package/dist/databases/query/index.js

@@ -0,0 +1,4 @@
+export { compensatedSum, compileQueryFilter, evaluateQuery, measureQuery, } from './evaluate.js';
+export * from './types.js';
+export { isValidQueryRequest, validateQueryExpr, validateQueryRequest } from './validate.js';
+export { asciiLower, compareCodePoints, isEmptyValue, normalizeDate } from './values.js';