@mintlify/common 1.0.1310 → 1.0.1312

package/dist/databases/formula/parse.js

@@ -0,0 +1,209 @@
+import { FormulaError, toFormulaError } from './errors.js';
+import { FORMULA_LIMITS } from './limits.js';
+import { isKeyword, tokenize } from './tokenize.js';
+export const PRECEDENCE = {
+    or: 1,
+    and: 2,
+    not: 3,
+    compare: 4,
+    sum: 5,
+    product: 6,
+    sign: 7,
+    power: 8,
+};
+const INFIX = {
+    or: { power: PRECEDENCE.or, operator: 'or' },
+    and: { power: PRECEDENCE.and, operator: 'and' },
+    '==': { power: PRECEDENCE.compare, operator: '==' },
+    '=': { power: PRECEDENCE.compare, operator: '==' },
+    '!=': { power: PRECEDENCE.compare, operator: '!=' },
+    '<': { power: PRECEDENCE.compare, operator: '<' },
+    '<=': { power: PRECEDENCE.compare, operator: '<=' },
+    '>': { power: PRECEDENCE.compare, operator: '>' },
+    '>=': { power: PRECEDENCE.compare, operator: '>=' },
+    '+': { power: PRECEDENCE.sum, operator: '+' },
+    '-': { power: PRECEDENCE.sum, operator: '-' },
+    '*': { power: PRECEDENCE.product, operator: '*' },
+    '/': { power: PRECEDENCE.product, operator: '/' },
+    '%': { power: PRECEDENCE.product, operator: '%' },
+    '^': { power: PRECEDENCE.power, operator: '^', rightAssociative: true },
+};
+const infixOf = (token) => {
+    if (token.type !== 'symbol' && token.type !== 'identifier')
+        return undefined;
+    const key = token.type === 'identifier' ? token.value.toLowerCase() : token.value;
+    return Object.hasOwn(INFIX, key) ? INFIX[key] : undefined;
+};
+const unexpected = (token) => token.type === 'eof'
+    ? new FormulaError('syntax', 'Unexpected end of formula', token.start)
+    : new FormulaError('syntax', `Unexpected '${token.type === 'string' ? 'string' : token.type === 'columnId' ? `#${token.value}` : token.value}'`, token.start, token.end);
+const parseTokens = (tokens) => {
+    let index = 0;
+    const peek = (offset = 0) => tokens[Math.min(index + offset, tokens.length - 1)];
+    const isSymbol = (token, value) => token.type === 'symbol' && token.value === value;
+    const expect = (value) => {
+        const token = peek();
+        if (!isSymbol(token, value)) {
+            throw new FormulaError('syntax', `Expected '${value}'`, token.start, token.end);
+        }
+        index++;
+        return token;
+    };
+    const parseCall = (name, depth) => {
+        index += 2;
+        const target = peek();
+        if (name.value === 'prop' && target.type === 'columnId' && isSymbol(peek(1), ')')) {
+            index++;
+            const end = expect(')').end;
+            return {
+                kind: 'ref',
+                name: '',
+                id: target.value,
+                form: 'id',
+                nameStart: target.start,
+                nameEnd: target.end,
+                start: name.start,
+                end,
+            };
+        }
+        const args = [];
+        if (!isSymbol(peek(), ')')) {
+            for (;;) {
+                args.push(parseExpression(0, depth + 1));
+                if (!isSymbol(peek(), ','))
+                    break;
+                index++;
+            }
+        }
+        const end = expect(')').end;
+        if (name.value !== 'prop') {
+            return { kind: 'call', name: name.value, args, start: name.start, end };
+        }
+        const [arg] = args;
+        if (args.length !== 1 || !arg) {
+            throw new FormulaError('arity', 'prop expects 1 argument', name.start, end);
+        }
+        if (arg.kind !== 'string') {
+            throw new FormulaError('syntax', 'prop expects a string literal', arg.start, arg.end);
+        }
+        return {
+            kind: 'ref',
+            name: arg.value,
+            form: 'prop',
+            nameStart: arg.start,
+            nameEnd: arg.end,
+            start: name.start,
+            end,
+        };
+    };
+    const parseIdentifier = (token, depth) => {
+        const keyword = token.value.toLowerCase();
+        if (keyword === 'true' || keyword === 'false') {
+            index++;
+            return { kind: 'boolean', value: keyword === 'true', start: token.start, end: token.end };
+        }
+        if (keyword === 'not') {
+            index++;
+            const operand = parseExpression(PRECEDENCE.not, depth + 1);
+            return { kind: 'unary', operator: 'not', operand, start: token.start, end: operand.end };
+        }
+        if (isKeyword(token.value))
+            throw unexpected(token);
+        if (isSymbol(peek(1), '('))
+            return parseCall(token, depth);
+        index++;
+        return {
+            kind: 'ref',
+            name: token.value,
+            form: 'bare',
+            nameStart: token.start,
+            nameEnd: token.end,
+            start: token.start,
+            end: token.end,
+        };
+    };
+    const parsePrefix = (depth) => {
+        const token = peek();
+        if (token.type === 'number') {
+            index++;
+            const value = Number(token.value);
+            if (!Number.isFinite(value)) {
+                throw new FormulaError('syntax', 'Number is too large', token.start, token.end);
+            }
+            return { kind: 'number', value, start: token.start, end: token.end };
+        }
+        if (token.type === 'string') {
+            index++;
+            return { kind: 'string', value: token.value, start: token.start, end: token.end };
+        }
+        if (token.type === 'identifier')
+            return parseIdentifier(token, depth);
+        if (isSymbol(token, '(')) {
+            index++;
+            const inner = parseExpression(0, depth + 1);
+            expect(')');
+            return inner;
+        }
+        if (isSymbol(token, '-') || isSymbol(token, '+')) {
+            index++;
+            const operand = parseExpression(PRECEDENCE.sign, depth + 1);
+            return {
+                kind: 'unary',
+                operator: token.value === '-' ? '-' : '+',
+                operand,
+                start: token.start,
+                end: operand.end,
+            };
+        }
+        throw unexpected(token);
+    };
+    const parseExpression = (minPower, depth) => {
+        if (depth > FORMULA_LIMITS.depth) {
+            const token = peek();
+            throw new FormulaError('depth', 'Formula is nested too deeply', token.start, token.end);
+        }
+        let left = parsePrefix(depth);
+        for (;;) {
+            const token = peek();
+            const infix = infixOf(token);
+            if (!infix || infix.power < minPower)
+                return left;
+            index++;
+            const right = parseExpression(infix.rightAssociative ? infix.power : infix.power + 1, depth + 1);
+            left = {
+                kind: 'binary',
+                operator: infix.operator,
+                operatorStart: token.start,
+                operatorEnd: token.end,
+                left,
+                right,
+                start: left.start,
+                end: right.end,
+            };
+        }
+    };
+    if (peek().type === 'eof')
+        return { kind: 'empty', start: 0, end: 0 };
+    const ast = parseExpression(0, 0);
+    if (peek().type !== 'eof')
+        throw unexpected(peek());
+    return ast;
+};
+const encoder = new TextEncoder();
+export const parseFormula = (source, { maxBytes = FORMULA_LIMITS.sourceBytes } = {}) => {
+    try {
+        if (typeof source !== 'string') {
+            return { error: new FormulaError('syntax', 'Formula must be text', 0) };
+        }
+        const bytes = encoder.encode(source).byteLength;
+        if (bytes > maxBytes) {
+            return {
+                error: new FormulaError('too_long', `Formula exceeds ${maxBytes} bytes`, 0, source.length),
+            };
+        }
+        return { ast: parseTokens(tokenize(source)) };
+    }
+    catch (error) {
+        return { error: toFormulaError(error) };
+    }
+};

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

@@ -0,0 +1,20 @@
+import type { FormulaNode } from './ast.js';
+import { FormulaError } from './errors.js';
+import type { FormulaColumn } from './types.js';
+export type FormulaReference = {
+    id: string | null;
+    name: string | null;
+    start: number;
+    end: number;
+};
+export declare const referencedColumns: (ast: FormulaNode, columns?: readonly Pick<FormulaColumn, 'id' | 'name'>[]) => FormulaReference[];
+export type StoredFormulaResult = {
+    source: string;
+} | {
+    error: FormulaError;
+};
+export declare const toStoredFormula: (source: string, columns: readonly Pick<FormulaColumn, 'id' | 'name'>[]) => StoredFormulaResult;
+export declare const toDisplayFormula: (source: string, columns: readonly Pick<FormulaColumn, 'id' | 'name'>[]) => string;
+export declare const displayDiagnostics: (display: string, columns: readonly Pick<FormulaColumn, 'id' | 'name'>[]) => FormulaError[];
+export declare const isStoredFormula: (source: string) => boolean;
+export declare const renameColumn: (source: string, oldName: string, newName: string) => string;

package/dist/databases/formula/references.js

@@ -0,0 +1,76 @@
+import { FormulaError } from './errors.js';
+import { columnIdReference, columnReference, quoteString } from './format.js';
+import { FORMULA_LIMITS } from './limits.js';
+import { parseFormula } from './parse.js';
+import { refsOf, rewrite } from './rewrite.js';
+const lookup = (columns) => {
+    const byId = new Map(columns.map((column) => [column.id, column]));
+    const byName = new Map();
+    const ambiguous = new Set();
+    for (const column of columns) {
+        if (byName.has(column.name))
+            ambiguous.add(column.name);
+        else
+            byName.set(column.name, column);
+    }
+    return { byId, byName, ambiguous };
+};
+export const referencedColumns = (ast, columns) => {
+    const { byId, byName } = lookup(columns !== null && columns !== void 0 ? columns : []);
+    return refsOf(ast).map((node) => { var _a, _b; var _c, _d; return node.id === undefined
+        ? { id: (_c = (_a = byName.get(node.name)) === null || _a === void 0 ? void 0 : _a.id) !== null && _c !== void 0 ? _c : null, name: node.name, start: node.start, end: node.end }
+        : { id: node.id, name: (_d = (_b = byId.get(node.id)) === null || _b === void 0 ? void 0 : _b.name) !== null && _d !== void 0 ? _d : null, start: node.start, end: node.end }; });
+};
+const encoder = new TextEncoder();
+export const toStoredFormula = (source, columns) => {
+    const { byName } = lookup(columns);
+    const stored = rewrite(source, (node) => {
+        const column = node.id === undefined ? byName.get(node.name) : undefined;
+        return column ? { start: node.start, end: node.end, text: columnIdReference(column.id) } : null;
+    });
+    if (encoder.encode(stored).byteLength <= FORMULA_LIMITS.sourceBytes)
+        return { source: stored };
+    return {
+        error: new FormulaError('too_long', `Formula exceeds ${FORMULA_LIMITS.sourceBytes} bytes once property names are saved as ids`, 0, source.length),
+    };
+};
+export const toDisplayFormula = (source, columns) => {
+    const { byId, ambiguous } = lookup(columns);
+    return rewrite(source, (node) => {
+        const column = node.id === undefined ? undefined : byId.get(node.id);
+        if (!column || ambiguous.has(column.name))
+            return null;
+        return { start: node.start, end: node.end, text: columnReference(column.name) };
+    });
+};
+export const displayDiagnostics = (display, columns) => {
+    const parsed = parseFormula(display, { maxBytes: FORMULA_LIMITS.draftBytes });
+    if ('error' in parsed)
+        return [];
+    const { byId, ambiguous } = lookup(columns);
+    return refsOf(parsed.ast).flatMap((node) => {
+        var _a;
+        const name = node.id === undefined ? node.name : (_a = byId.get(node.id)) === null || _a === void 0 ? void 0 : _a.name;
+        if (name === undefined || !ambiguous.has(name))
+            return [];
+        const message = node.id === undefined
+            ? `More than one property is named '${name}'; this uses the first`
+            : `More than one property is named '${name}'; shown by id`;
+        return [new FormulaError('ambiguous_property', message, node.start, node.end, 'warning')];
+    });
+};
+export const isStoredFormula = (source) => {
+    const parsed = parseFormula(source);
+    return 'ast' in parsed && refsOf(parsed.ast).every((node) => node.id !== undefined);
+};
+export const renameColumn = (source, oldName, newName) => {
+    if (oldName === newName)
+        return source;
+    return rewrite(source, (node) => {
+        if (node.id !== undefined || node.name !== oldName)
+            return null;
+        return node.form === 'prop'
+            ? { start: node.nameStart, end: node.nameEnd, text: quoteString(newName) }
+            : { start: node.start, end: node.end, text: columnReference(newName) };
+    });
+};

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

@@ -0,0 +1,16 @@
+import { type FormulaNode, type FormulaRefNode } from './ast.js';
+export type Edit = {
+    start: number;
+    end: number;
+    text: string;
+};
+export declare const refsOf: (ast: FormulaNode) => (import("./ast.js").Span & {
+    kind: 'ref';
+    name: string;
+    id?: string;
+    form: 'bare' | 'prop' | 'id';
+    nameStart: number;
+    nameEnd: number;
+})[];
+export declare const rewrite: (source: string, edit: (node: FormulaRefNode) => Edit | null) => string;
+export declare const rewriteColumnIds: (source: string, resolve: (id: string) => string) => string;

package/dist/databases/formula/rewrite.js

@@ -0,0 +1,29 @@
+import { walkFormula } from './ast.js';
+import { columnIdReference } from './format.js';
+import { FORMULA_LIMITS } from './limits.js';
+import { parseFormula } from './parse.js';
+export const refsOf = (ast) => {
+    const refs = [];
+    walkFormula(ast, (node) => {
+        if (node.kind === 'ref')
+            refs.push(node);
+    });
+    return refs.sort((a, b) => a.start - b.start);
+};
+const applyEdits = (source, edits) => edits
+    .sort((a, b) => b.start - a.start)
+    .reduce((text, edit) => text.slice(0, edit.start) + edit.text + text.slice(edit.end), source);
+export const rewrite = (source, edit) => {
+    const parsed = parseFormula(source, { maxBytes: FORMULA_LIMITS.draftBytes });
+    if ('error' in parsed)
+        return source;
+    return applyEdits(source, refsOf(parsed.ast).flatMap((node) => { var _a; return (_a = edit(node)) !== null && _a !== void 0 ? _a : []; }));
+};
+export const rewriteColumnIds = (source, resolve) => rewrite(source, (node) => {
+    if (node.id === undefined)
+        return null;
+    const next = resolve(node.id);
+    return next === node.id
+        ? null
+        : { start: node.start, end: node.end, text: columnIdReference(next) };
+});

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

@@ -0,0 +1,29 @@
+import type { Analysis } from './analyze.js';
+import type { FormulaNode } from './ast.js';
+import { type FormulaParseResult } from './parse.js';
+import { type FormulaColumn, type TypeSet } from './types.js';
+export type OptionMaps = {
+    idsByLabel: Map<string, string[]>;
+    labelById: Map<string, string>;
+};
+export type Analyzer = (ast: FormulaNode, schema: Schema) => Analysis;
+type FormulaInfo = Pick<Analysis, 'type' | 'failed' | 'cyclic' | 'height' | 'volatile' | 'truncated'>;
+export declare class Schema {
+    readonly columns: readonly FormulaColumn[];
+    private readonly analyzer;
+    private readonly overrides;
+    readonly byId: Map<string, FormulaColumn>;
+    readonly byName: Map<string, FormulaColumn>;
+    private readonly options;
+    private readonly parsed;
+    private readonly analyses;
+    private active;
+    constructor(columns: readonly FormulaColumn[], analyzer: Analyzer, overrides?: ReadonlyMap<string, FormulaParseResult>);
+    withExpression(columnId: string, parsed: FormulaParseResult): Schema;
+    optionsOf(column: FormulaColumn): OptionMaps;
+    storedType(column: FormulaColumn): TypeSet;
+    parse(column: FormulaColumn): FormulaParseResult;
+    formula(column: FormulaColumn): FormulaInfo;
+    analysis(column: FormulaColumn): Analysis | undefined;
+}
+export {};

package/dist/databases/formula/schema.js

@@ -0,0 +1,117 @@
+import { FORMULA_LIMITS } from './limits.js';
+import { parseFormula } from './parse.js';
+import { ANY, BOOLEAN, DATE, NUMBER, STRING } from './types.js';
+const STORED_TYPES = {
+    number: NUMBER,
+    text: STRING,
+    url: STRING,
+    email: STRING,
+    select: STRING,
+    multi_select: STRING,
+    json: STRING,
+    boolean: BOOLEAN,
+    date: DATE,
+};
+const FLAGS = { volatile: false, truncated: false };
+const CYCLIC = Object.assign(Object.assign({}, FLAGS), { type: ANY, failed: true, cyclic: true, height: 0 });
+const BROKEN = Object.assign(Object.assign({}, FLAGS), { type: ANY, failed: true, cyclic: false, height: 0 });
+const TOO_DEEP = Object.assign(Object.assign({}, FLAGS), { truncated: true, type: ANY, failed: true, cyclic: false, height: FORMULA_LIMITS.depth });
+const optionMaps = (column) => {
+    var _a;
+    const idsByLabel = new Map();
+    const labelById = new Map();
+    for (const option of (_a = column.options) !== null && _a !== void 0 ? _a : []) {
+        const { id, label } = typeof option === 'string' ? { id: option, label: option } : option;
+        const ids = idsByLabel.get(label);
+        if (!ids)
+            idsByLabel.set(label, [id]);
+        else if (!ids.includes(id))
+            ids.push(id);
+        labelById.set(id, label);
+    }
+    return { idsByLabel, labelById };
+};
+export class Schema {
+    constructor(columns, analyzer, overrides = new Map()) {
+        this.columns = columns;
+        this.analyzer = analyzer;
+        this.overrides = overrides;
+        this.byId = new Map();
+        this.byName = new Map();
+        this.options = new Map();
+        this.parsed = new Map();
+        this.analyses = new Map();
+        this.active = 0;
+        for (const column of columns) {
+            if (!this.byId.has(column.id))
+                this.byId.set(column.id, column);
+            if (!this.byName.has(column.name))
+                this.byName.set(column.name, column);
+        }
+    }
+    withExpression(columnId, parsed) {
+        return new Schema(this.columns, this.analyzer, new Map([[columnId, parsed]]));
+    }
+    optionsOf(column) {
+        let maps = this.options.get(column.id);
+        if (!maps) {
+            maps = optionMaps(column);
+            this.options.set(column.id, maps);
+        }
+        return maps;
+    }
+    storedType(column) {
+        return Object.hasOwn(STORED_TYPES, column.type) ? STORED_TYPES[column.type] : ANY;
+    }
+    parse(column) {
+        var _a;
+        const override = this.overrides.get(column.id);
+        if (override)
+            return override;
+        let parsed = this.parsed.get(column.id);
+        if (!parsed) {
+            const expression = (_a = column.config) === null || _a === void 0 ? void 0 : _a.expression;
+            parsed = parseFormula(typeof expression === 'string' ? expression : '');
+            this.parsed.set(column.id, parsed);
+        }
+        return parsed;
+    }
+    formula(column) {
+        var _a;
+        const known = this.analyses.get(column.id);
+        if (known === 'visiting')
+            return CYCLIC;
+        if (known)
+            return known;
+        if (this.active > FORMULA_LIMITS.depth)
+            return TOO_DEEP;
+        return (_a = this.analysis(column)) !== null && _a !== void 0 ? _a : BROKEN;
+    }
+    analysis(column) {
+        const known = this.analyses.get(column.id);
+        if (known === 'visiting')
+            return undefined;
+        if (known)
+            return known;
+        const parsed = this.parse(column);
+        if ('error' in parsed)
+            return undefined;
+        if (this.active > FORMULA_LIMITS.depth)
+            return undefined;
+        this.analyses.set(column.id, 'visiting');
+        this.active++;
+        try {
+            const analysis = this.analyzer(parsed.ast, this);
+            if (analysis.truncated)
+                this.analyses.delete(column.id);
+            else
+                this.analyses.set(column.id, analysis);
+            return analysis;
+        }
+        finally {
+            this.active--;
+            if (this.analyses.get(column.id) === 'visiting')
+                this.analyses.delete(column.id);
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+export type TokenType = 'number' | 'string' | 'identifier' | 'columnId' | 'symbol' | 'eof';
+export type Token = {
+    type: TokenType;
+    value: string;
+    start: number;
+    end: number;
+};
+export declare const KEYWORDS: ReadonlySet<string>;
+export declare const isKeyword: (value: string) => boolean;
+export declare const isBareName: (name: string) => boolean;
+export declare const tokenize: (source: string) => Token[];

package/dist/databases/formula/tokenize.js

@@ -0,0 +1,114 @@
+import { FormulaError } from './errors.js';
+const SYMBOLS = [
+    '==',
+    '!=',
+    '<=',
+    '>=',
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '^',
+    '<',
+    '>',
+    '=',
+    '(',
+    ')',
+    ',',
+];
+const ESCAPES = { n: '\n', t: '\t', r: '\r' };
+export const KEYWORDS = new Set(['and', 'or', 'not', 'true', 'false']);
+export const isKeyword = (value) => KEYWORDS.has(value.toLowerCase());
+export const isBareName = (name) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) && !isKeyword(name) && name !== 'prop';
+const isDigit = (char) => char.length === 1 && char >= '0' && char <= '9';
+const isIdentifierStart = (char) => /^[A-Za-z_]$/.test(char);
+const isIdentifierPart = (char) => /^[A-Za-z0-9_]$/.test(char);
+const isColumnIdPart = (char) => /^[A-Za-z0-9_-]$/.test(char);
+const isWhitespace = (char) => /^\s$/.test(char);
+const readDigits = (source, start) => {
+    let index = start;
+    while (isDigit(source.charAt(index)))
+        index++;
+    return index;
+};
+const readNumber = (source, start) => {
+    let index = readDigits(source, start);
+    if (source.charAt(index) === '.')
+        index = readDigits(source, index + 1);
+    const exponent = source.charAt(index);
+    if (exponent !== 'e' && exponent !== 'E')
+        return index;
+    let next = index + 1;
+    if (source.charAt(next) === '+' || source.charAt(next) === '-')
+        next++;
+    if (!isDigit(source.charAt(next))) {
+        throw new FormulaError('syntax', 'Invalid number', start, next);
+    }
+    return readDigits(source, next);
+};
+const readString = (source, start) => {
+    var _a;
+    const quote = source.charAt(start);
+    let value = '';
+    let index = start + 1;
+    while (index < source.length) {
+        const char = source.charAt(index);
+        if (char === quote)
+            return { value, end: index + 1 };
+        if (char === '\\' && index + 1 < source.length) {
+            const next = source.charAt(index + 1);
+            value += (_a = ESCAPES[next]) !== null && _a !== void 0 ? _a : next;
+            index += 2;
+            continue;
+        }
+        value += char;
+        index++;
+    }
+    throw new FormulaError('syntax', 'Unterminated string', start, source.length);
+};
+export const tokenize = (source) => {
+    var _a;
+    const tokens = [];
+    let index = 0;
+    while (index < source.length) {
+        const char = source.charAt(index);
+        if (isWhitespace(char)) {
+            index++;
+            continue;
+        }
+        const start = index;
+        if (isDigit(char) || (char === '.' && isDigit(source.charAt(index + 1)))) {
+            index = readNumber(source, start);
+            tokens.push({ type: 'number', value: source.slice(start, index), start, end: index });
+        }
+        else if (char === '"' || char === "'") {
+            const { value, end } = readString(source, start);
+            index = end;
+            tokens.push({ type: 'string', value, start, end });
+        }
+        else if (char === '#' && isColumnIdPart(source.charAt(index + 1))) {
+            index++;
+            while (isColumnIdPart(source.charAt(index)))
+                index++;
+            tokens.push({ type: 'columnId', value: source.slice(start + 1, index), start, end: index });
+        }
+        else if (isIdentifierStart(char)) {
+            index++;
+            while (isIdentifierPart(source.charAt(index)))
+                index++;
+            tokens.push({ type: 'identifier', value: source.slice(start, index), start, end: index });
+        }
+        else {
+            const symbol = SYMBOLS.find((candidate) => source.startsWith(candidate, start));
+            if (!symbol) {
+                const unexpected = String.fromCodePoint((_a = source.codePointAt(start)) !== null && _a !== void 0 ? _a : 0);
+                throw new FormulaError('syntax', `Unexpected '${unexpected}'`, start, start + unexpected.length);
+            }
+            index += symbol.length;
+            tokens.push({ type: 'symbol', value: symbol, start, end: index });
+        }
+    }
+    tokens.push({ type: 'eof', value: '', start: source.length, end: source.length });
+    return tokens;
+};

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

@@ -0,0 +1,11 @@
+import type { FormulaNode } from './ast.js';
+import { type FormulaError } from './errors.js';
+import { type FormulaColumn, type FormulaType } from './types.js';
+export type TypecheckResult = {
+    type: FormulaType;
+    diagnostics: FormulaError[];
+    volatile: boolean;
+};
+export declare const typecheck: (ast: FormulaNode, columns: readonly FormulaColumn[], options?: {
+    columnId?: string;
+}) => TypecheckResult;

package/dist/databases/formula/typecheck.js

@@ -0,0 +1,16 @@
+import { analyzeFor } from './analyze.js';
+import { toFormulaError } from './errors.js';
+import { typeName } from './types.js';
+export const typecheck = (ast, columns, options = {}) => {
+    try {
+        const { analysis } = analyzeFor(ast, columns, options.columnId);
+        return {
+            type: typeName(analysis.type),
+            diagnostics: [...analysis.diagnostics].sort((a, b) => a.start - b.start),
+            volatile: analysis.volatile,
+        };
+    }
+    catch (error) {
+        return { type: 'any', diagnostics: [toFormulaError(error)], volatile: false };
+    }
+};