@mintlify/common 1.0.1312 → 1.0.1314

package/dist/databases/view.js

@@ -0,0 +1,604 @@
+import { formulaFilterEngine } from './formula/filter.js';
+import { columnReference, quoteString } from './formula/format.js';
+import { FORMULA_LIMITS } from './formula/limits.js';
+import { parseFormula } from './formula/parse.js';
+import { referencedColumns, renameColumn, toDisplayFormula, toStoredFormula, } from './formula/references.js';
+import { isKeyword, tokenize } from './formula/tokenize.js';
+import { typecheck } from './formula/typecheck.js';
+import { evaluateQuery } from './query/evaluate.js';
+import { QUERY_LIMITS } from './query/types.js';
+import { normalizeDate } from './query/values.js';
+export { columnReference } from './formula/format.js';
+export const DATABASE_VIEWS = ['table', 'board'];
+export const DATABASE_FILTER_OPS = [
+    'eq',
+    'neq',
+    'lt',
+    'lte',
+    'gt',
+    'gte',
+    'contains',
+    'not_contains',
+    'empty',
+    'not_empty',
+    'any_of',
+    'contains_any',
+];
+const FILTER_KINDS = {
+    text: 'text',
+    url: 'text',
+    email: 'text',
+    number: 'number',
+    select: 'select',
+    multi_select: 'multi',
+    boolean: 'checkbox',
+    date: 'date',
+};
+export const filterKindOf = (type) => { var _a; return (_a = FILTER_KINDS[type]) !== null && _a !== void 0 ? _a : null; };
+export const isViewableColumn = (column) => filterKindOf(column.type) !== null;
+export const isSortableColumn = (column) => isViewableColumn(column) && column.type !== 'multi_select';
+export const isGroupableColumn = (column) => column.type === 'select';
+const OPS_BY_KIND = {
+    text: ['contains', 'not_contains', 'eq', 'neq', 'empty', 'not_empty'],
+    number: ['eq', 'neq', 'lt', 'lte', 'gt', 'gte', 'empty', 'not_empty'],
+    select: ['eq', 'neq', 'any_of', 'empty', 'not_empty'],
+    multi: ['contains', 'not_contains', 'contains_any', 'empty', 'not_empty'],
+    checkbox: ['eq', 'empty', 'not_empty'],
+    date: ['lt', 'gt', 'eq', 'empty', 'not_empty'],
+};
+export const filterOpsFor = (type) => {
+    const kind = filterKindOf(type);
+    return kind ? OPS_BY_KIND[kind] : [];
+};
+export const isKnownView = (value) => DATABASE_VIEWS.some((view) => view === value);
+export const resolveView = (value) => (isKnownView(value) ? value : 'table');
+export const normalizeColumnName = (name) => name.trim();
+const isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === 'string');
+const isDateValue = (value) => typeof value === 'object' &&
+    value !== null &&
+    !Array.isArray(value) &&
+    'date' in value &&
+    typeof value.date === 'string';
+const isListOp = (op) => op === 'any_of' || op === 'contains_any';
+export const isEmptinessOp = (op) => op === 'empty' || op === 'not_empty';
+export const isCompleteRule = ({ op, value }) => {
+    if (isEmptinessOp(op))
+        return true;
+    if (isListOp(op))
+        return isStringArray(value) && value.length > 0;
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (isDateValue(value))
+        return value.date !== '';
+    return (typeof value === 'string' && value !== '') || typeof value === 'boolean';
+};
+export const isInvalidDateRule = ({ value }) => isDateValue(value) && value.date !== '' && normalizeDate(value.date) === null;
+const safeTokens = (source) => {
+    try {
+        return tokenize(source);
+    }
+    catch (_a) {
+        return null;
+    }
+};
+const readName = (tokens, index) => {
+    const token = tokens[index];
+    if ((token === null || token === void 0 ? void 0 : token.type) === 'string')
+        return { name: token.value, next: index + 1 };
+    if ((token === null || token === void 0 ? void 0 : token.type) !== 'identifier')
+        return null;
+    const open = tokens[index + 1];
+    if (token.value === 'prop') {
+        const name = tokens[index + 2];
+        const close = tokens[index + 3];
+        if ((open === null || open === void 0 ? void 0 : open.value) !== '(' || (name === null || name === void 0 ? void 0 : name.type) !== 'string' || (close === null || close === void 0 ? void 0 : close.value) !== ')')
+            return null;
+        return { name: name.value, next: index + 4 };
+    }
+    if (isKeyword(token.value) || ((open === null || open === void 0 ? void 0 : open.type) === 'symbol' && open.value === '('))
+        return null;
+    return { name: token.value, next: index + 1 };
+};
+const splitSortKeys = (source) => {
+    const keys = [];
+    let quote = null;
+    let start = 0;
+    for (let index = 0; index < source.length; index++) {
+        const char = source.charAt(index);
+        if (quote) {
+            if (char === '\\')
+                index++;
+            else if (char === quote)
+                quote = null;
+        }
+        else if (char === '"' || char === "'") {
+            quote = char;
+        }
+        else if (char === ',') {
+            keys.push(source.slice(start, index));
+            start = index + 1;
+        }
+    }
+    keys.push(source.slice(start));
+    return keys;
+};
+const parseSortKey = (source) => {
+    var _a;
+    const tokens = safeTokens(source);
+    if (!tokens)
+        return null;
+    const minus = tokens[0];
+    const descending = (minus === null || minus === void 0 ? void 0 : minus.type) === 'symbol' && minus.value === '-';
+    const ref = readName(tokens, descending ? 1 : 0);
+    if (!ref || ((_a = tokens[ref.next]) === null || _a === void 0 ? void 0 : _a.type) !== 'eof')
+        return null;
+    return { column: ref.name, direction: descending ? 'desc' : 'asc' };
+};
+export const parseSortKeys = (source) => (source === null || source === void 0 ? void 0 : source.trim())
+    ? splitSortKeys(source).map((key) => ({ source: key.trim(), rule: parseSortKey(key) }))
+    : [];
+export const parseSort = (source) => {
+    const rules = [];
+    for (const { rule } of parseSortKeys(source)) {
+        if (!rule)
+            return null;
+        rules.push(rule);
+    }
+    return rules;
+};
+export const serializeSort = (rules) => rules.length > 0
+    ? rules
+        .map(({ column, direction }) => `${direction === 'desc' ? '-' : ''}${columnReference(column)}`)
+        .join(', ')
+    : null;
+const COMPARE_OPS = {
+    '==': 'eq',
+    '!=': 'neq',
+    '<': 'lt',
+    '<=': 'lte',
+    '>': 'gt',
+    '>=': 'gte',
+};
+const MIRRORED = {
+    eq: 'eq',
+    neq: 'neq',
+    lt: 'gt',
+    lte: 'gte',
+    gt: 'lt',
+    gte: 'lte',
+};
+const OP_SOURCE = {
+    eq: '==',
+    neq: '!=',
+    lt: '<',
+    lte: '<=',
+    gt: '>',
+    gte: '>=',
+};
+const refName = (node) => (node === null || node === void 0 ? void 0 : node.kind) === 'ref' && node.form !== 'id' ? node.name : null;
+const literalOf = (node) => {
+    switch (node.kind) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+            return node.value;
+        case 'unary':
+            return node.operator === '-' && node.operand.kind === 'number'
+                ? -node.operand.value
+                : undefined;
+        case 'call': {
+            const [arg] = node.args;
+            return node.name === 'date' && node.args.length === 1 && (arg === null || arg === void 0 ? void 0 : arg.kind) === 'string'
+                ? { date: arg.value }
+                : undefined;
+        }
+        default:
+            return undefined;
+    }
+};
+const flatten = (node, operator) => node.kind === 'binary' && node.operator === operator
+    ? [...flatten(node.left, operator), ...flatten(node.right, operator)]
+    : [node];
+const containsOf = (node) => {
+    if (node.kind !== 'call' || node.name !== 'contains' || node.args.length !== 2)
+        return null;
+    const [subject, needle] = node.args;
+    const column = refName(subject);
+    return column !== null && (needle === null || needle === void 0 ? void 0 : needle.kind) === 'string' ? { column, value: needle.value } : null;
+};
+const BLANK_OPS = {
+    eq: 'empty',
+    neq: 'not_empty',
+};
+const compareRule = (column, op, value) => {
+    const blank = value === '' ? BLANK_OPS[op] : undefined;
+    return blank ? { column, op: blank, value: null } : { column, op, value };
+};
+const emptyOf = (node) => {
+    if (node.kind !== 'call' || node.name !== 'empty' || node.args.length !== 1)
+        return null;
+    return refName(node.args[0]);
+};
+const atomRule = (node) => {
+    if (node.kind === 'binary') {
+        const op = COMPARE_OPS[node.operator];
+        if (!op)
+            return null;
+        const left = refName(node.left);
+        const right = refName(node.right);
+        if (left !== null && right === null) {
+            const value = literalOf(node.right);
+            return value === undefined ? null : compareRule(left, op, value);
+        }
+        if (right !== null && left === null) {
+            const value = literalOf(node.left);
+            const mirrored = MIRRORED[op];
+            return value === undefined || !mirrored ? null : compareRule(right, mirrored, value);
+        }
+        return null;
+    }
+    if (node.kind === 'unary' && node.operator === 'not') {
+        const inner = containsOf(node.operand);
+        if (inner)
+            return { column: inner.column, op: 'not_contains', value: inner.value };
+        const blank = emptyOf(node.operand);
+        return blank === null ? null : { column: blank, op: 'not_empty', value: null };
+    }
+    const contains = containsOf(node);
+    if (contains)
+        return { column: contains.column, op: 'contains', value: contains.value };
+    const blank = emptyOf(node);
+    return blank === null ? null : { column: blank, op: 'empty', value: null };
+};
+const groupRule = (atoms) => {
+    const rules = atoms.map(atomRule);
+    const [first] = rules;
+    if (!first || rules.some((rule) => (rule === null || rule === void 0 ? void 0 : rule.column) !== first.column))
+        return null;
+    const values = rules.map((rule) => rule === null || rule === void 0 ? void 0 : rule.value);
+    if (!isStringArray(values))
+        return null;
+    if (rules.every((rule) => (rule === null || rule === void 0 ? void 0 : rule.op) === 'eq')) {
+        return { column: first.column, op: 'any_of', value: values };
+    }
+    if (rules.every((rule) => (rule === null || rule === void 0 ? void 0 : rule.op) === 'contains')) {
+        return { column: first.column, op: 'contains_any', value: values };
+    }
+    return null;
+};
+const rulesOf = (ast) => {
+    const rules = [];
+    for (const clause of flatten(ast, 'and')) {
+        const atoms = flatten(clause, 'or');
+        const rule = atoms.length === 1 ? atomRule(clause) : groupRule(atoms);
+        if (!rule)
+            return null;
+        rules.push(rule);
+    }
+    return rules;
+};
+export const parseFilter = (source) => {
+    const trimmed = source === null || source === void 0 ? void 0 : source.trim();
+    if (!trimmed)
+        return { kind: 'none' };
+    const parsed = parseFormula(trimmed);
+    const rules = 'ast' in parsed && parsed.ast.kind !== 'empty' ? rulesOf(parsed.ast) : null;
+    return rules ? { kind: 'rules', rules } : { kind: 'custom', source: trimmed };
+};
+const literalSource = (value) => {
+    if (typeof value === 'string')
+        return quoteString(value);
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    if (isDateValue(value))
+        return `date(${quoteString(value.date)})`;
+    return '""';
+};
+const ruleSource = ({ column, op, value }) => {
+    var _a;
+    const reference = columnReference(column);
+    const values = isStringArray(value) ? value : [];
+    const group = (parts) => { var _a; return parts.length === 1 ? ((_a = parts[0]) !== null && _a !== void 0 ? _a : '') : `(${parts.join(' or ')})`; };
+    switch (op) {
+        case 'empty':
+            return `empty(${reference})`;
+        case 'not_empty':
+            return `not empty(${reference})`;
+        case 'contains':
+            return `contains(${reference}, ${literalSource(value)})`;
+        case 'not_contains':
+            return `not contains(${reference}, ${literalSource(value)})`;
+        case 'any_of':
+            return group(values.map((entry) => `${reference} == ${quoteString(entry)}`));
+        case 'contains_any':
+            return group(values.map((entry) => `contains(${reference}, ${quoteString(entry)})`));
+        default:
+            return `${reference} ${(_a = OP_SOURCE[op]) !== null && _a !== void 0 ? _a : '=='} ${literalSource(value)}`;
+    }
+};
+const rulesSource = (rules) => {
+    const parts = rules.filter(isCompleteRule).map(ruleSource);
+    return parts.length > 0 ? parts.join(' and ') : null;
+};
+export const serializeFilter = (filter) => {
+    if (filter.kind === 'custom')
+        return filter.source.trim() || null;
+    if (filter.kind === 'none')
+        return null;
+    return rulesSource(filter.rules);
+};
+const PLACEHOLDER = 'view-rename-';
+const placeholderId = (index) => `${PLACEHOLDER}${index}`;
+const leaksPlaceholder = (source) => {
+    const parsed = parseFormula(source, { maxBytes: FORMULA_LIMITS.draftBytes });
+    return ('ast' in parsed && referencedColumns(parsed.ast).some((ref) => { var _a; return (_a = ref.id) === null || _a === void 0 ? void 0 : _a.startsWith(PLACEHOLDER); }));
+};
+const renameFormula = (source, renames) => {
+    const entries = [...renames].filter(([from, to]) => from !== to);
+    if (entries.length === 0)
+        return source;
+    const [only] = entries;
+    if (entries.length === 1 && only)
+        return renameColumn(source, only[0], only[1]);
+    const targets = [...new Set(entries.map(([, to]) => to))];
+    const idOf = (name) => placeholderId(targets.indexOf(name));
+    const stored = toStoredFormula(source, entries.map(([from, to]) => ({ id: idOf(to), name: from })));
+    if ('error' in stored)
+        return source;
+    const renamed = toDisplayFormula(stored.source, targets.map((name) => ({ id: idOf(name), name })));
+    return leaksPlaceholder(renamed) ? source : renamed;
+};
+export const resolveColumnName = (written, candidates) => {
+    const name = normalizeColumnName(written);
+    const exact = candidates.find((candidate) => normalizeColumnName(candidate.name) === name);
+    if (exact)
+        return { column: exact };
+    const folded = name.toLowerCase();
+    const loose = candidates.filter((candidate) => normalizeColumnName(candidate.name).toLowerCase() === folded);
+    const [first] = loose;
+    if (loose.length === 1 && first)
+        return { column: first };
+    return { column: null, reason: loose.length > 1 ? 'ambiguous' : 'unknown' };
+};
+export const matchColumnName = (written, candidates) => { var _a; return (_a = resolveColumnName(written, candidates).column) !== null && _a !== void 0 ? _a : undefined; };
+const renamedGroupBy = (written, renames) => { var _a; return (_a = matchColumnName(written, [...renames].map(([name, to]) => ({ name, to })))) === null || _a === void 0 ? void 0 : _a.to; };
+export const renameColumnsInViewProps = (props, renames) => {
+    const changes = {};
+    if (renames.size === 0)
+        return changes;
+    const keys = parseSortKeys(props.sort);
+    const renamedKey = ({ source, rule }) => {
+        const to = rule && renames.get(rule.column);
+        return rule && to ? serializeSort([Object.assign(Object.assign({}, rule), { column: to })]) : source;
+    };
+    const filter = props.filter ? renameFormula(props.filter, renames) : props.filter;
+    const groupBy = props.groupBy
+        ? renamedGroupBy(normalizeColumnName(props.groupBy), renames)
+        : undefined;
+    if (keys.some(({ rule }) => rule && renames.has(rule.column))) {
+        changes.sort = keys.map(renamedKey).join(', ');
+    }
+    if (filter !== props.filter)
+        changes.filter = filter;
+    if (groupBy !== undefined)
+        changes.groupBy = groupBy;
+    return changes;
+};
+export const renameColumnInViewProps = (props, from, to) => renameColumnsInViewProps(props, new Map([[from, to]]));
+const aliasTargets = (columns) => {
+    var _a, _b;
+    const targets = new Map();
+    for (const column of columns) {
+        for (const alias of (_a = column.aliases) !== null && _a !== void 0 ? _a : []) {
+            if (resolveColumnName(alias, columns).column)
+                continue;
+            const claimed = (_b = targets.get(alias)) !== null && _b !== void 0 ? _b : [];
+            if (!claimed.some((entry) => entry.id === column.id))
+                claimed.push(column);
+            targets.set(alias, claimed);
+        }
+    }
+    return targets;
+};
+export const aliasRenames = (columns) => {
+    const renames = new Map();
+    for (const [alias, [column, ...others]] of aliasTargets(columns)) {
+        if (column && others.length === 0)
+            renames.set(alias, column.name);
+    }
+    return renames;
+};
+export const ambiguousAliases = (columns) => new Set([...aliasTargets(columns)].flatMap(([alias, claimed]) => (claimed.length > 1 ? [alias] : [])));
+const nameWarning = (prop, column, reason, columns) => reason === 'ambiguous' || ambiguousAliases(columns).has(column)
+    ? { kind: 'ambiguous_column', prop, column }
+    : { kind: 'unknown_column', prop, column };
+export const resolveGroupBy = (written, columns) => {
+    var _a;
+    const name = written ? normalizeColumnName(written) : '';
+    if (!name)
+        return { column: (_a = columns.find(isGroupableColumn)) !== null && _a !== void 0 ? _a : null, warnings: [] };
+    const match = resolveColumnName(name, columns);
+    if (!match.column) {
+        return { column: null, warnings: [nameWarning('groupBy', name, match.reason, columns)] };
+    }
+    const { column } = match;
+    if (!isGroupableColumn(column)) {
+        return {
+            column: null,
+            warnings: [{ kind: 'group_by_unsupported', column: column.name, type: column.type }],
+        };
+    }
+    return { column, warnings: [] };
+};
+const ALL_ROWS = () => true;
+const NO_ROWS = () => false;
+const canonicalNames = (source, columns, warn) => {
+    const parsed = parseFormula(source);
+    if (!('ast' in parsed))
+        return source;
+    const written = new Set(referencedColumns(parsed.ast).flatMap((ref) => (ref.id === null && ref.name ? [ref.name] : [])));
+    let canonical = source;
+    for (const name of written) {
+        if (columns.some((column) => column.name === name))
+            continue;
+        const match = resolveColumnName(name, columns);
+        if (match.column)
+            canonical = renameColumn(canonical, name, match.column.name);
+        else
+            warn(normalizeColumnName(name), match.reason);
+    }
+    return canonical;
+};
+export const resolveViewProps = (written, columns, { onInvalidFilter = 'show-all' } = {}) => {
+    var _a, _b;
+    var _c, _d;
+    const healed = renameColumnsInViewProps(written, aliasRenames(columns));
+    if (written.groupBy && matchColumnName(written.groupBy, columns))
+        delete healed.groupBy;
+    const props = Object.assign(Object.assign({}, written), healed);
+    const warnings = [];
+    let filterInvalid = false;
+    const known = (prop, name) => {
+        const match = resolveColumnName(name, columns);
+        if (match.column)
+            return match.column;
+        warnings.push(nameWarning(prop, normalizeColumnName(name), match.reason, columns));
+        if (prop === 'filter')
+            filterInvalid = true;
+        return undefined;
+    };
+    const rawView = ((_a = props.view) === null || _a === void 0 ? void 0 : _a.trim()) || null;
+    if (rawView && !isKnownView(rawView))
+        warnings.push({ kind: 'unknown_view', view: rawView });
+    const sort = [];
+    const querySort = [];
+    for (const key of parseSortKeys(props.sort)) {
+        if (!key.rule) {
+            warnings.push({ kind: 'sort_invalid', key: key.source });
+            continue;
+        }
+        const column = known('sort', key.rule.column);
+        const rule = { column: (_c = column === null || column === void 0 ? void 0 : column.name) !== null && _c !== void 0 ? _c : key.rule.column, direction: key.rule.direction };
+        sort.push(rule);
+        if (!column)
+            continue;
+        if (!isSortableColumn(column)) {
+            warnings.push({ kind: 'unsortable', column: column.name, type: column.type });
+        }
+        else if (querySort.some((entry) => entry.columnId === column.id)) {
+            warnings.push({ kind: 'sort_ignored', column: column.name, reason: 'duplicate' });
+        }
+        else if (querySort.length >= QUERY_LIMITS.sortKeys) {
+            warnings.push({ kind: 'sort_ignored', column: column.name, reason: 'limit' });
+        }
+        else {
+            querySort.push({ columnId: column.id, direction: rule.direction });
+        }
+    }
+    const parsedFilter = parseFilter(props.filter);
+    const filter = parsedFilter.kind === 'rules'
+        ? {
+            kind: 'rules',
+            rules: parsedFilter.rules.map((rule) => { var _a; var _b; return (Object.assign(Object.assign({}, rule), { column: (_b = (_a = resolveColumnName(rule.column, columns).column) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : rule.column })); }),
+        }
+        : parsedFilter;
+    let filterSource = null;
+    if (filter.kind === 'rules') {
+        const active = filter.rules.flatMap((rule) => {
+            const column = known('filter', rule.column);
+            if (!column)
+                return [];
+            if (isInvalidDateRule(rule) && isDateValue(rule.value)) {
+                warnings.push({ kind: 'invalid_date', column: column.name, value: rule.value.date });
+                filterInvalid = true;
+                return [];
+            }
+            return [Object.assign(Object.assign({}, rule), { column: column.name })];
+        });
+        filterSource = rulesSource(active);
+    }
+    else if (filter.kind === 'custom') {
+        filterSource = canonicalNames(filter.source, columns, (column, reason) => {
+            warnings.push(nameWarning('filter', column, reason, columns));
+            filterInvalid = true;
+        });
+    }
+    let matches = ALL_ROWS;
+    if (filterSource) {
+        const compiled = formulaFilterEngine(filterSource, columns);
+        if ('error' in compiled) {
+            if (!filterInvalid) {
+                warnings.push({ kind: 'filter_error', source: filterSource, message: compiled.error });
+            }
+            filterInvalid = true;
+        }
+        else {
+            matches = compiled.test;
+        }
+    }
+    if (filterInvalid && onInvalidFilter === 'hide-all')
+        matches = NO_ROWS;
+    const stored = filterSource ? toStoredFormula(filterSource, columns) : null;
+    const group = resolveGroupBy(props.groupBy, columns);
+    warnings.push(...group.warnings);
+    return {
+        view: resolveView(rawView),
+        sort,
+        filter,
+        groupBy: (_d = (_b = group.column) === null || _b === void 0 ? void 0 : _b.name) !== null && _d !== void 0 ? _d : null,
+        warnings,
+        healed,
+        filterSource: matches === ALL_ROWS || matches === NO_ROWS ? null : filterSource,
+        filterInvalid,
+        querySort,
+        rulesKey: JSON.stringify([
+            querySort,
+            stored && 'source' in stored ? stored.source : filterSource,
+        ]),
+        matches,
+        sortRows: (rows) => {
+            const result = evaluateQuery({ sort: querySort }, rows, columns);
+            if ('error' in result)
+                return [...rows];
+            const byId = new Map(rows.map((row) => [row.id, row]));
+            return result.ids.flatMap((id) => {
+                const row = byId.get(id);
+                return row ? [row] : [];
+            });
+        },
+    };
+};
+export const filterDiagnostic = (source, columns) => {
+    const parsed = parseFormula(source);
+    if ('error' in parsed) {
+        const { description, start, end } = parsed.error;
+        return { message: description, start, end };
+    }
+    const named = [...columns];
+    for (const ref of referencedColumns(parsed.ast)) {
+        if (ref.id !== null || ref.name === null)
+            continue;
+        const match = resolveColumnName(ref.name, columns);
+        const name = normalizeColumnName(ref.name);
+        if (match.column) {
+            named.push(Object.assign(Object.assign({}, match.column), { name: ref.name }));
+            continue;
+        }
+        const message = match.reason === 'ambiguous' || ambiguousAliases(columns).has(name)
+            ? `"${name}" matches more than one property`
+            : `No property named "${name}"`;
+        return { message, start: ref.start, end: ref.end };
+    }
+    const { type, diagnostics } = typecheck(parsed.ast, named);
+    const failure = diagnostics.find((diagnostic) => diagnostic.severity === 'error');
+    if (failure)
+        return { message: failure.description, start: failure.start, end: failure.end };
+    if (type !== 'boolean') {
+        return { message: 'A filter must be true or false', start: 0, end: source.length };
+    }
+    return null;
+};
+export const applyView = (columns, rows, props, { keep, onInvalidFilter } = {}) => {
+    const { matches, sortRows } = resolveViewProps(props, columns, { onInvalidFilter });
+    return sortRows(rows.filter((row) => (keep === null || keep === void 0 ? void 0 : keep(row)) || matches(row)));
+};

package/dist/mdx/preprocessCustomHeadingIds.js

@@ -7,7 +7,7 @@ const MDX_HEADING_ID_RE = /^(\s*)(#{1,6})\s+(.+?)\s*\{\s*#([^}]+?)\s*\}\s*$/;
 // `<MDX>` or `<MDX className="x">`; not `<MDX />` (no body) and not `<MDXProvider>`
 const MDX_OPEN_RE = /<MDX(?:\s[^>]*[^/>\s])?\s*>/g;
 const MDX_CLOSE_RE = /<\/MDX\s*>/g;
-const COMMENT_MASK_RE = /(`+).*?\1|"[^"\n]*"/g;
+const COMMENT_MASK_RE = /(`+).*?\1|=\s*'[^'\n]*'|"[^"\n]*"/g;
 const UNSAFE_HTML_ATTR_CHARS = /[<>"]/g;
 /**
  * Characters to strip from custom heading IDs in the default (non-editor) path.

package/dist/mdx/preprocessCustomHeadingIds.test.js

@@ -179,4 +179,11 @@ describe('customHeadingIdSourceLines', () => {
         expect(sourceLines).toEqual([1, 1, 1, 2, 3, 4, 5, 6, 6, 6]);
         expect(sourceLines).toHaveLength(preprocessCustomHeadingIds(content).split('\n').length);
     });
+    it('ignores comment markers inside single-quoted attribute values', () => {
+        const input = `<Database filter='Name == "a\\"{/*"' />\n\n## Heading {#custom}`;
+        expect(preprocessCustomHeadingIds(input)).toContain('<h2 id="custom">');
+    });
+    it('still treats a comment after an apostrophe in prose as a comment', () => {
+        expect(preprocessCustomHeadingIds("It's {/* hidden\n## Heading {#custom}\n*/}")).toContain('## Heading {#custom}');
+    });
 });