@mintlify/common 1.0.1310 → 1.0.1311

package/dist/databases/formula/function-docs.js

@@ -0,0 +1,63 @@
+export const FORMULA_FUNCTIONS = [
+    {
+        name: 'if',
+        signature: 'if(condition, then, else)',
+        description: 'Returns then when condition is true, otherwise else.',
+    },
+    {
+        name: 'concat',
+        signature: 'concat(value, …)',
+        description: 'Joins values into one piece of text.',
+    },
+    { name: 'length', signature: 'length(text)', description: 'Number of characters in text.' },
+    { name: 'lower', signature: 'lower(text)', description: 'Lowercases text.' },
+    { name: 'upper', signature: 'upper(text)', description: 'Uppercases text.' },
+    {
+        name: 'contains',
+        signature: 'contains(text, text)',
+        description: 'Whether text contains other text, ignoring ASCII case.',
+    },
+    {
+        name: 'startsWith',
+        signature: 'startsWith(text, text)',
+        description: 'Whether text starts with other text, ignoring ASCII case.',
+    },
+    {
+        name: 'endsWith',
+        signature: 'endsWith(text, text)',
+        description: 'Whether text ends with other text, ignoring ASCII case.',
+    },
+    {
+        name: 'round',
+        signature: 'round(number, digits)',
+        description: 'Rounds half away from zero to digits places.',
+    },
+    { name: 'floor', signature: 'floor(number)', description: 'Rounds down.' },
+    { name: 'ceil', signature: 'ceil(number)', description: 'Rounds up.' },
+    { name: 'abs', signature: 'abs(number)', description: 'Absolute value.' },
+    { name: 'min', signature: 'min(number, …)', description: 'Smallest number, ignoring blanks.' },
+    { name: 'max', signature: 'max(number, …)', description: 'Largest number, ignoring blanks.' },
+    { name: 'now', signature: 'now()', description: 'The current date and time.' },
+    {
+        name: 'dateAdd',
+        signature: 'dateAdd(date, amount, unit)',
+        description: 'Adds years, months, weeks, days, hours, minutes or seconds to a date.',
+    },
+    {
+        name: 'dateBetween',
+        signature: 'dateBetween(date, date, unit)',
+        description: 'Whole units from the second date to the first.',
+    },
+    {
+        name: 'date',
+        signature: 'date(text)',
+        description: 'An ISO 8601 date. Comparisons with a date-only value match the whole UTC day.',
+    },
+    { name: 'format', signature: 'format(value)', description: 'Turns any value into text.' },
+    {
+        name: 'toNumber',
+        signature: 'toNumber(value)',
+        description: 'Turns text, booleans or dates into a number.',
+    },
+    { name: 'empty', signature: 'empty(value)', description: 'Whether a value is blank.' },
+];

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

@@ -0,0 +1,21 @@
+import type { Span } from './ast.js';
+import { type TextBudget } from './errors.js';
+import { type FormulaScalar, type TypeSet } from './types.js';
+export type FunctionContext = {
+    now: () => Date;
+    text: TextBudget;
+};
+export type Thunk = () => FormulaScalar;
+export type FormulaFunction = {
+    min: number;
+    max: number;
+    params: (index: number) => TypeSet;
+    returns: (args: readonly TypeSet[]) => TypeSet;
+    call: (args: readonly Thunk[], span: Span, context: FunctionContext) => FormulaScalar;
+    apply?: (values: readonly FormulaScalar[], span: Span, context: FunctionContext) => FormulaScalar;
+};
+export declare const expectLogical: (name: string, value: FormulaScalar, span: Span) => boolean;
+export declare const DATE_FUNCTIONS: ReadonlySet<string>;
+export declare const getFunction: (name: string) => FormulaFunction | undefined;
+export declare const FORMULA_FUNCTION_NAMES: readonly string[];
+export declare const arityMessage: (name: string, fn: FormulaFunction) => string;

package/dist/databases/formula/functions.js

@@ -0,0 +1,161 @@
+import { asciiLower } from '../query/values.js';
+import { addToDate, dateDifference, parseDateUnit } from './dates.js';
+import { FormulaError, joinText, limitText } from './errors.js';
+import { ANY, BOOLEAN, DATE, NUMBER, STRING } from './types.js';
+import { formatFormulaValue, isEmptyScalar, parseDateValue } from './values.js';
+const mismatch = (name, expected, span) => new FormulaError('type', `${name} expects ${expected}`, span.start, span.end);
+const expectNumber = (name, value, span) => {
+    if (value === null || typeof value === 'number')
+        return value;
+    throw mismatch(name, 'number', span);
+};
+const expectText = (name, value, span) => {
+    if (value === null || typeof value === 'string')
+        return value;
+    throw mismatch(name, 'text', span);
+};
+const expectDate = (name, value, span) => {
+    if (value === null || value instanceof Date)
+        return value;
+    throw mismatch(name, 'date', span);
+};
+export const expectLogical = (name, value, span) => {
+    if (value === null)
+        return false;
+    if (typeof value === 'boolean')
+        return value;
+    throw mismatch(name, 'boolean', span);
+};
+const all = (args) => args.map((arg) => arg());
+const at = (values, index) => { var _a; return (_a = values[index]) !== null && _a !== void 0 ? _a : null; };
+const fixed = (types) => () => types;
+const define = (min, max, params, returns, call) => ({
+    min,
+    max,
+    params: (index) => { var _a; return (typeof params === 'number' ? params : ((_a = params[index]) !== null && _a !== void 0 ? _a : ANY)); },
+    returns: typeof returns === 'number' ? fixed(returns) : returns,
+    call: (args, span, context) => call(all(args), span, context),
+    apply: call,
+});
+const numeric = (name, fn) => define(1, 1, NUMBER, NUMBER, (values, span) => {
+    const value = expectNumber(name, at(values, 0), span);
+    return value === null ? null : fn(value);
+});
+const textual = (name, returns, fn) => define(1, 1, STRING, returns, (values, span, context) => {
+    const value = expectText(name, at(values, 0), span);
+    return value === null ? null : fn(value, span, context);
+});
+const matcher = (name, match) => define(2, 2, STRING, BOOLEAN, (values, span) => {
+    const haystack = expectText(name, at(values, 0), span);
+    const needle = expectText(name, at(values, 1), span);
+    if (!haystack || !needle)
+        return false;
+    return match(asciiLower(haystack), asciiLower(needle));
+});
+const extremum = (name, pick) => define(1, Infinity, NUMBER, NUMBER, (values, span) => {
+    const numbers = values
+        .map((value) => expectNumber(name, value, span))
+        .filter((value) => value !== null);
+    return numbers.length ? pick(...numbers) : null;
+});
+const roundTo = (value, digits) => {
+    const places = Math.trunc(digits);
+    if (places >= 0 && (Number.isInteger(value) || places > 15))
+        return value;
+    const sign = Math.sign(value);
+    const magnitude = Math.abs(value);
+    if (places < 0) {
+        const factor = Math.pow(10, -places);
+        if (!Number.isFinite(factor))
+            return 0;
+        return sign * Math.round(Number((magnitude / factor).toPrecision(15))) * factor;
+    }
+    const factor = Math.pow(10, places);
+    const scaled = Number((magnitude * factor).toPrecision(15));
+    return Number.isFinite(scaled) ? (sign * Math.round(scaled)) / factor : value;
+};
+const toNumber = (value) => {
+    if (value === null || typeof value === 'number')
+        return value;
+    if (typeof value === 'boolean')
+        return value ? 1 : 0;
+    if (value instanceof Date)
+        return value.getTime();
+    const trimmed = value.trim();
+    const parsed = trimmed === '' ? NaN : Number(trimmed);
+    return Number.isFinite(parsed) ? parsed : null;
+};
+export const DATE_FUNCTIONS = new Set(['dateAdd', 'dateBetween']);
+const FUNCTIONS = {
+    if: {
+        min: 3,
+        max: 3,
+        params: (index) => (index === 0 ? BOOLEAN : ANY),
+        returns: (args) => { var _a, _b; return ((_a = args[1]) !== null && _a !== void 0 ? _a : ANY) | ((_b = args[2]) !== null && _b !== void 0 ? _b : ANY); },
+        call: (args, span) => {
+            var _a, _b;
+            var _c, _d;
+            const condition = expectLogical('if', (_c = (_a = args[0]) === null || _a === void 0 ? void 0 : _a.call(args)) !== null && _c !== void 0 ? _c : null, span);
+            return (_d = (_b = (condition ? args[1] : args[2])) === null || _b === void 0 ? void 0 : _b()) !== null && _d !== void 0 ? _d : null;
+        },
+    },
+    concat: define(1, Infinity, ANY, STRING, (values, span, context) => joinText(values.map(formatFormulaValue), span.start, span.end, context.text)),
+    length: textual('length', NUMBER, (value) => Array.from(value).length),
+    lower: textual('lower', STRING, (value, span, context) => limitText(value.toLowerCase(), span.start, span.end, context.text)),
+    upper: textual('upper', STRING, (value, span, context) => limitText(value.toUpperCase(), span.start, span.end, context.text)),
+    contains: matcher('contains', (h, n) => h.includes(n)),
+    startsWith: matcher('startsWith', (h, n) => h.startsWith(n)),
+    endsWith: matcher('endsWith', (h, n) => h.endsWith(n)),
+    round: define(1, 2, NUMBER, NUMBER, (values, span) => {
+        const value = expectNumber('round', at(values, 0), span);
+        const digits = values.length > 1 ? expectNumber('round', at(values, 1), span) : 0;
+        return value === null || digits === null ? null : roundTo(value, digits);
+    }),
+    floor: numeric('floor', Math.floor),
+    ceil: numeric('ceil', Math.ceil),
+    abs: numeric('abs', Math.abs),
+    min: extremum('min', Math.min),
+    max: extremum('max', Math.max),
+    now: define(0, 0, ANY, DATE, (_values, _span, context) => context.now()),
+    dateAdd: define(3, 3, [DATE, NUMBER, STRING], DATE, (values, span) => {
+        const date = expectDate('dateAdd', at(values, 0), span);
+        const amount = expectNumber('dateAdd', at(values, 1), span);
+        const unit = expectText('dateAdd', at(values, 2), span);
+        if (date === null || amount === null || unit === null)
+            return null;
+        return addToDate(date, amount, parseDateUnit(unit, span.start));
+    }),
+    dateBetween: define(3, 3, [DATE, DATE, STRING], NUMBER, (values, span) => {
+        const first = expectDate('dateBetween', at(values, 0), span);
+        const second = expectDate('dateBetween', at(values, 1), span);
+        const unit = expectText('dateBetween', at(values, 2), span);
+        if (first === null || second === null || unit === null)
+            return null;
+        return dateDifference(first, second, parseDateUnit(unit, span.start));
+    }),
+    date: define(1, 1, STRING | DATE, DATE, (values, span) => {
+        const value = at(values, 0);
+        if (value === null || value instanceof Date)
+            return value;
+        if (typeof value !== 'string')
+            throw mismatch('date', 'text', span);
+        const date = parseDateValue(value);
+        if (!date)
+            throw new FormulaError('type', `'${value}' is not an ISO 8601 date`, span.start, span.end);
+        return date;
+    }),
+    format: define(1, 1, ANY, STRING, (values, span, context) => limitText(formatFormulaValue(at(values, 0)), span.start, span.end, context.text)),
+    toNumber: define(1, 1, ANY, NUMBER, (values) => toNumber(at(values, 0))),
+    empty: define(1, 1, ANY, BOOLEAN, (values) => isEmptyScalar(at(values, 0))),
+};
+export const getFunction = (name) => Object.hasOwn(FUNCTIONS, name) ? FUNCTIONS[name] : undefined;
+export const FORMULA_FUNCTION_NAMES = Object.keys(FUNCTIONS);
+const plural = (count) => `${count} argument${count === 1 ? '' : 's'}`;
+export const arityMessage = (name, fn) => {
+    const expected = fn.min === fn.max
+        ? plural(fn.min)
+        : fn.max === Infinity
+            ? `at least ${plural(fn.min)}`
+            : `${fn.min} to ${fn.max} arguments`;
+    return `${name} expects ${expected}`;
+};

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

@@ -0,0 +1,7 @@
+export type FormulaTokenKind = 'number' | 'string' | 'keyword' | 'function' | 'property' | 'operator' | 'punctuation' | 'invalid';
+export type FormulaToken = {
+    kind: FormulaTokenKind;
+    start: number;
+    end: number;
+};
+export declare const highlightFormula: (source: string) => FormulaToken[];

package/dist/databases/formula/highlight.js

@@ -0,0 +1,54 @@
+import { FormulaError } from './errors.js';
+import { getFunction } from './functions.js';
+import { isKeyword, tokenize } from './tokenize.js';
+const classify = (token, next) => {
+    switch (token.type) {
+        case 'number':
+            return 'number';
+        case 'string':
+            return 'string';
+        case 'columnId':
+            return 'property';
+        case 'identifier':
+            if (isKeyword(token.value))
+                return 'keyword';
+            if ((next === null || next === void 0 ? void 0 : next.type) === 'symbol' && next.value === '(') {
+                return token.value === 'prop' || getFunction(token.value) ? 'function' : 'invalid';
+            }
+            return 'property';
+        default:
+            return token.value === '(' || token.value === ')' || token.value === ','
+                ? 'punctuation'
+                : 'operator';
+    }
+};
+const lex = (source) => {
+    let end = source.length;
+    for (;;) {
+        try {
+            return {
+                tokens: tokenize(source.slice(0, end)),
+                failedAt: end === source.length ? null : end,
+            };
+        }
+        catch (error) {
+            end = Math.min(error instanceof FormulaError ? error.start : 0, end - 1);
+            if (end <= 0)
+                return { tokens: [], failedAt: 0 };
+        }
+    }
+};
+export const highlightFormula = (source) => {
+    if (typeof source !== 'string')
+        return [];
+    const { tokens, failedAt } = lex(source);
+    const real = tokens.filter((token) => token.type !== 'eof');
+    const spans = real.map((token, index) => ({
+        kind: classify(token, real[index + 1]),
+        start: token.start,
+        end: token.end,
+    }));
+    return failedAt === null
+        ? spans
+        : [...spans, { kind: 'invalid', start: failedAt, end: source.length }];
+};

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

@@ -0,0 +1,16 @@
+export type { BinaryOperator, FormulaNode, Span, UnaryOperator } from './ast.js';
+export { compile, compileColumns, type ColumnPrograms, type CompiledFormula, type CompileOptions, } from './compile.js';
+export { FormulaError, isFormulaError, type FormulaErrorCode, type FormulaSeverity, } from './errors.js';
+export { columnIdReference, columnReference, formatFormula, quoteString } from './format.js';
+export { formulaFilterEngine, type FormulaFilter } from './filter.js';
+export { FORMULA_FUNCTIONS, type FormulaFunctionDoc } from './function-docs.js';
+export { highlightFormula, type FormulaToken, type FormulaTokenKind } from './highlight.js';
+export { FORMULA_LIMITS } from './limits.js';
+export { toQueryIR, type QueryLowering } from './lower.js';
+export { parseFormula, type FormulaParseResult, type ParseOptions } from './parse.js';
+export { displayDiagnostics, isStoredFormula, referencedColumns, renameColumn, toDisplayFormula, toStoredFormula, type StoredFormulaResult, type FormulaReference, } from './references.js';
+export { rewriteColumnIds } from './rewrite.js';
+export { isBareName, KEYWORDS } from './tokenize.js';
+export { typecheck, type TypecheckResult } from './typecheck.js';
+export type { FormulaColumn, FormulaOption, FormulaRow, FormulaScalar, FormulaType, FormulaValue, } from './types.js';
+export { formatFormulaValue } from './values.js';

package/dist/databases/formula/index.js

@@ -0,0 +1,14 @@
+export { compile, compileColumns, } from './compile.js';
+export { FormulaError, isFormulaError, } from './errors.js';
+export { columnIdReference, columnReference, formatFormula, quoteString } from './format.js';
+export { formulaFilterEngine } from './filter.js';
+export { FORMULA_FUNCTIONS } from './function-docs.js';
+export { highlightFormula } from './highlight.js';
+export { FORMULA_LIMITS } from './limits.js';
+export { toQueryIR } from './lower.js';
+export { parseFormula } from './parse.js';
+export { displayDiagnostics, isStoredFormula, referencedColumns, renameColumn, toDisplayFormula, toStoredFormula, } from './references.js';
+export { rewriteColumnIds } from './rewrite.js';
+export { isBareName, KEYWORDS } from './tokenize.js';
+export { typecheck } from './typecheck.js';
+export { formatFormulaValue } from './values.js';

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

@@ -0,0 +1,8 @@
+export declare const FORMULA_LIMITS: {
+    readonly sourceBytes: 2048;
+    readonly draftBytes: 16384;
+    readonly depth: 64;
+    readonly steps: 200000;
+    readonly textBytes: 102400;
+    readonly rowTextBytes: 1048576;
+};

package/dist/databases/formula/limits.js

@@ -0,0 +1,8 @@
+export const FORMULA_LIMITS = {
+    sourceBytes: 2048,
+    draftBytes: 16384,
+    depth: 64,
+    steps: 200000,
+    textBytes: 102400,
+    rowTextBytes: 1048576,
+};

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

@@ -0,0 +1,9 @@
+import { type QueryExpr } from '../query/types.js';
+import type { FormulaNode } from './ast.js';
+import type { FormulaColumn } from './types.js';
+export type QueryLowering = {
+    ir: QueryExpr;
+} | {
+    unsupported: string;
+};
+export declare const toQueryIR: (ast: FormulaNode, columns: readonly FormulaColumn[]) => QueryLowering;

package/dist/databases/formula/lower.js

@@ -0,0 +1,252 @@
+import { measureQuery } from '../query/evaluate.js';
+import { CLIENT_ONLY, QUERY_LIMITS, } from '../query/types.js';
+import { analyzeFor } from './analyze.js';
+import { BOOLEAN } from './types.js';
+const OPS = {
+    '==': 'eq',
+    '!=': 'ne',
+    '<': 'lt',
+    '<=': 'lte',
+    '>': 'gt',
+    '>=': 'gte',
+};
+const MIRRORED = {
+    eq: 'eq',
+    ne: 'ne',
+    lt: 'gt',
+    lte: 'gte',
+    gt: 'lt',
+    gte: 'lte',
+};
+const TEXT_FUNCTIONS = {
+    contains: 'contains',
+    startsWith: 'startsWith',
+    endsWith: 'endsWith',
+};
+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 idsAreLabels = (column) => { var _a; return ((_a = column.options) !== null && _a !== void 0 ? _a : []).every((option) => typeof option === 'string' || option.id === option.label); };
+class Unsupported extends Error {
+}
+const unsupported = (reason) => new Unsupported(reason);
+class Lowerer {
+    constructor(analysis) {
+        this.analysis = analysis;
+    }
+    condition(node) {
+        switch (node.kind) {
+            case 'boolean':
+                return { kind: 'literal', value: node.value };
+            case 'ref': {
+                const column = this.column(node);
+                if (column.type !== 'boolean')
+                    throw unsupported(`'${column.name}' is not a condition`);
+                return { kind: 'column', id: column.id };
+            }
+            case 'unary':
+                if (node.operator !== 'not')
+                    throw unsupported('Arithmetic runs on the client');
+                return { kind: 'not', arg: this.condition(node.operand) };
+            case 'binary': {
+                if (node.operator === 'and' || node.operator === 'or') {
+                    const kind = node.operator;
+                    const args = [node.left, node.right].flatMap((side) => {
+                        const lowered = this.condition(side);
+                        return lowered.kind === kind ? lowered.args : [lowered];
+                    });
+                    return { kind, args };
+                }
+                const op = OPS[node.operator];
+                if (!op)
+                    throw unsupported('Arithmetic runs on the client');
+                return this.compare(op, node.left, node.right);
+            }
+            case 'call':
+                return this.call(node);
+            default:
+                throw unsupported('Not a condition');
+        }
+    }
+    optionOf(node) {
+        const option = this.analysis.options.get(node);
+        if (option === null)
+            throw unsupported('Option ids are compared on the client');
+        return option;
+    }
+    call(node) {
+        var _a;
+        const member = this.analysis.memberships.get(node);
+        if (member) {
+            const ids = node.args[1] ? this.optionOf(node.args[1]) : undefined;
+            return this.anyOption({ kind: 'column', id: this.column((_a = node.args[0]) !== null && _a !== void 0 ? _a : node).id }, ids !== null && ids !== void 0 ? ids : [], true);
+        }
+        const textOp = TEXT_FUNCTIONS[node.name];
+        if (textOp) {
+            const [subject, needle] = node.args;
+            if (!subject || !needle)
+                throw unsupported(`${node.name} needs two arguments`);
+            const column = this.column(subject);
+            if (kindOf(column.type) !== 'text') {
+                throw unsupported(`${node.name} on '${column.name}' runs on the client`);
+            }
+            if (needle.kind !== 'string')
+                throw unsupported(`${node.name} needs a text value`);
+            return {
+                kind: 'text',
+                op: textOp,
+                left: { kind: 'column', id: column.id },
+                right: { kind: 'literal', value: needle.value },
+            };
+        }
+        if (node.name === 'empty') {
+            const [subject] = node.args;
+            if (!subject)
+                throw unsupported('empty needs an argument');
+            return { kind: 'isEmpty', arg: { kind: 'column', id: this.column(subject).id } };
+        }
+        throw unsupported(`${node.name}() runs on the client`);
+    }
+    compare(op, left, right) {
+        var _a;
+        const dayOnRight = this.analysis.days.get(right);
+        const day = dayOnRight !== null && dayOnRight !== void 0 ? dayOnRight : this.analysis.days.get(left);
+        if (day) {
+            const side = this.operand(dayOnRight ? left : right);
+            if (side.kind !== 'column')
+                throw unsupported('Comparisons need a property');
+            return this.day(dayOnRight ? op : MIRRORED[op], side, day);
+        }
+        const selects = [left, right].flatMap((side) => {
+            const column = side.kind === 'ref' ? this.analysis.columns.get(side) : undefined;
+            return (column === null || column === void 0 ? void 0 : column.type) === 'select' ? [column] : [];
+        });
+        const select = selects.find((column) => !idsAreLabels(column));
+        if (select && (selects.length > 1 || (op !== 'eq' && op !== 'ne'))) {
+            throw unsupported(`'${select.name}' is ordered by option name on the client`);
+        }
+        const a = this.operand(left);
+        const b = this.operand(right);
+        if (a.kind !== 'column' && b.kind !== 'column') {
+            throw unsupported('Comparisons need a property');
+        }
+        const label = [left, right].find((side) => { var _a; var _b; return side.kind === 'string' && ((_b = (_a = this.analysis.options.get(side)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 1; });
+        if (label && (op === 'eq' || op === 'ne')) {
+            const subject = label === left ? right : left;
+            const any = this.anyOption(label === left ? b : a, (_a = this.optionOf(label)) !== null && _a !== void 0 ? _a : [], this.column(subject).type === 'multi_select');
+            return op === 'eq' ? any : { kind: 'not', arg: any };
+        }
+        if (a.kind === 'column' && b.kind === 'column') {
+            const first = this.column(left);
+            const second = this.column(right);
+            if (kindOf(first.type) !== kindOf(second.type)) {
+                throw unsupported(`'${first.name}' and '${second.name}' are compared on the client`);
+            }
+        }
+        return { kind: 'compare', op, left: a, right: b };
+    }
+    anyOption(column, ids, multi) {
+        const eq = (value) => ({
+            kind: 'compare',
+            op: 'eq',
+            left: column,
+            right: { kind: 'literal', value },
+        });
+        const [only] = ids;
+        if (ids.length <= 1)
+            return eq(only !== null && only !== void 0 ? only : null);
+        return multi ? { kind: 'or', args: ids.map(eq) } : { kind: 'in', arg: column, values: ids };
+    }
+    day(op, column, day) {
+        const at = (bound) => ({ kind: 'literal', value: bound.toISOString() });
+        const compare = (operator, bound) => ({
+            kind: 'compare',
+            op: operator,
+            left: column,
+            right: at(bound),
+        });
+        switch (op) {
+            case 'eq':
+                return { kind: 'and', args: [compare('gte', day.start), compare('lt', day.end)] };
+            case 'ne':
+                return {
+                    kind: 'not',
+                    arg: { kind: 'and', args: [compare('gte', day.start), compare('lt', day.end)] },
+                };
+            case 'lt':
+                return compare('lt', day.start);
+            case 'lte':
+                return compare('lt', day.end);
+            case 'gt':
+                return compare('gte', day.end);
+            case 'gte':
+                return compare('gte', day.start);
+        }
+    }
+    operand(node) {
+        var _a;
+        var _b;
+        const constant = node.kind === 'call' ? this.analysis.dates.get(node) : undefined;
+        if (constant)
+            return { kind: 'literal', value: constant.toISOString() };
+        switch (node.kind) {
+            case 'ref':
+                return { kind: 'column', id: this.column(node).id };
+            case 'string': {
+                const date = this.analysis.dates.get(node);
+                if (date)
+                    return { kind: 'literal', value: date.toISOString() };
+                return { kind: 'literal', value: (_b = (_a = this.optionOf(node)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : node.value };
+            }
+            case 'number':
+            case 'boolean':
+                return { kind: 'literal', value: node.value };
+            case 'unary':
+                if (node.operator === '-' && node.operand.kind === 'number') {
+                    return { kind: 'literal', value: -node.operand.value };
+                }
+                throw unsupported('Arithmetic runs on the client');
+            default:
+                throw unsupported('Calculated values run on the client');
+        }
+    }
+    column(node) {
+        const column = node.kind === 'ref' ? this.analysis.columns.get(node) : undefined;
+        if (!column)
+            throw unsupported('Expected a property');
+        if (column.type === 'formula')
+            throw unsupported(CLIENT_ONLY);
+        if (!kindOf(column.type))
+            throw unsupported(`${column.type} properties run on the client`);
+        return column;
+    }
+}
+export const toQueryIR = (ast, columns) => {
+    try {
+        const { analysis } = analyzeFor(ast, columns);
+        const failure = analysis.diagnostics.find((diagnostic) => diagnostic.severity === 'error');
+        if (failure)
+            return { unsupported: failure.message };
+        if (analysis.type !== BOOLEAN)
+            return { unsupported: 'Not a condition' };
+        const ir = new Lowerer(analysis).condition(ast);
+        const { depth, nodes } = measureQuery(ir);
+        if (depth > QUERY_LIMITS.depth || nodes > QUERY_LIMITS.nodes) {
+            return { unsupported: 'Too complex to run in the database' };
+        }
+        return { ir };
+    }
+    catch (error) {
+        if (error instanceof Unsupported)
+            return { unsupported: error.message };
+        return { unsupported: 'Runs on the client' };
+    }
+};

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

@@ -0,0 +1,21 @@
+import type { FormulaNode } from './ast.js';
+import { FormulaError } from './errors.js';
+export type FormulaParseResult = {
+    ast: FormulaNode;
+} | {
+    error: FormulaError;
+};
+export declare const PRECEDENCE: {
+    or: number;
+    and: number;
+    not: number;
+    compare: number;
+    sum: number;
+    product: number;
+    sign: number;
+    power: number;
+};
+export type ParseOptions = {
+    maxBytes?: number;
+};
+export declare const parseFormula: (source: string, { maxBytes }?: ParseOptions) => FormulaParseResult;