@script-it/json-views-core 0.1.0-beta.1

package/dist/safe-pattern.d.ts

@@ -0,0 +1,5 @@
+import { RE2JS } from 're2js';
+/** RE2 syntax provides linear-time matching; unsupported constructs fail compilation.
+ * Pattern size and cache count also bound compilation input and retained programs.
+ */
+export declare function compileSafePattern(source: string): RE2JS;

package/dist/safe-pattern.js

@@ -0,0 +1,20 @@
+import { RE2JS } from 're2js';
+const MAX_PATTERN_LENGTH = 4096;
+const MAX_CACHED_PATTERNS = 128;
+const patterns = new Map();
+/** RE2 syntax provides linear-time matching; unsupported constructs fail compilation.
+ * Pattern size and cache count also bound compilation input and retained programs.
+ */
+export function compileSafePattern(source) {
+    if (typeof source !== 'string' || source.length > MAX_PATTERN_LENGTH) {
+        throw new TypeError(`pattern must be a string of at most ${MAX_PATTERN_LENGTH} characters`);
+    }
+    const existing = patterns.get(source);
+    if (existing)
+        return existing;
+    const compiled = RE2JS.compile(source);
+    if (patterns.size >= MAX_CACHED_PATTERNS)
+        patterns.delete(patterns.keys().next().value);
+    patterns.set(source, compiled);
+    return compiled;
+}

package/dist/schema-validation.d.ts

@@ -0,0 +1,3 @@
+import type { JsonViewSchemaDescriptor } from './metadata.js';
+import { type JsonViewTypeRegistry } from './type-registry.js';
+export declare function validateJsonViewSchemaValue(value: unknown, descriptor: JsonViewSchemaDescriptor, typeRegistry?: JsonViewTypeRegistry): string | undefined;

package/dist/schema-validation.js

@@ -0,0 +1,4 @@
+import { defaultTypeRegistry } from './type-registry.js';
+export function validateJsonViewSchemaValue(value, descriptor, typeRegistry = defaultTypeRegistry) {
+    return typeRegistry.validate(value, descriptor);
+}

package/dist/source-default.d.ts

@@ -0,0 +1,2 @@
+/** Initial presentation only. Never changes a user's selection during edits. */
+export declare function prefersSource(content: string, metadata?: unknown): boolean;

package/dist/source-default.js

@@ -0,0 +1,39 @@
+import { compileJsonViewMetadata } from './metadata.js';
+import { isJsonViewTableCandidate } from './table-suitability.js';
+/** Initial presentation only. Never changes a user's selection during edits. */
+export function prefersSource(content, metadata) {
+    try {
+        const root = JSON.parse(content);
+        const compiled = compileJsonViewMetadata(root, undefined, metadata === undefined ? {} : { metadata });
+        if (compiled.metadataSource !== 'inferred' || compiled.views.length || isJsonViewTableCandidate(root))
+            return false;
+        const formatted = JSON.stringify(root, null, 2);
+        const lines = formatted.split('\n').length;
+        if (formatted.length > 8000 || lines > 100)
+            return false;
+        const entries = root !== null && typeof root === 'object' ? Object.values(root) : [];
+        // A compact root with little visible information is easier to read whole
+        // than by opening each nested value, even when nesting is only one level.
+        if (entries.length <= 5 && formatted.length <= 3000 && lines <= 40
+            && entries.some((value) => value !== null && typeof value === 'object' && Object.keys(value).length > 0
+                // Flat lists are simple field values, not structural nesting.
+                && (!Array.isArray(value) || value.some((item) => item !== null && typeof item === 'object'))))
+            return true;
+        let leaves = 0;
+        let hidden = 0;
+        const visit = (value, depth) => {
+            if (value !== null && typeof value === 'object')
+                Object.values(value).forEach((child) => visit(child, depth + 1));
+            else {
+                leaves++;
+                if (depth >= 3)
+                    hidden++;
+            }
+        };
+        visit(root, 0);
+        return leaves > 0 && hidden / leaves >= 0.6;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/table-suitability.d.ts

@@ -0,0 +1,5 @@
+/** Conservative eligibility shared by predicted views and automatic JSON tables. */
+/** Two or more records with fields can render as rows and columns. */
+export declare function isJsonViewTableCandidate(value: unknown): boolean;
+/** Shared scalar paths only; never explodes arrays or rewrites source records. */
+export declare function inferFlatColumnPaths(value: unknown): string[][] | undefined;

package/dist/table-suitability.js

@@ -0,0 +1,55 @@
+/** Conservative eligibility shared by predicted views and automatic JSON tables. */
+const MIN_RECORDS = 2;
+const MAX_SAMPLE_ROWS = 10;
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isReadable(value) {
+    return typeof value === 'boolean'
+        || (typeof value === 'number' && Number.isFinite(value))
+        || (typeof value === 'string' && value.trim().length > 0);
+}
+/** Two or more records with fields can render as rows and columns. */
+export function isJsonViewTableCandidate(value) {
+    const rows = Array.isArray(value) ? value : isRecord(value) ? Object.values(value) : [];
+    return rows.length >= MIN_RECORDS && rows.every(isRecord)
+        && rows.some((row) => Object.keys(row).some((key) => key !== '$jsonviews'));
+}
+/** Shared scalar paths only; never explodes arrays or rewrites source records. */
+export function inferFlatColumnPaths(value) {
+    if (!Array.isArray(value) || value.length < MIN_RECORDS || !value.every(isRecord))
+        return undefined;
+    const sample = value.slice(0, MAX_SAMPLE_ROWS);
+    const shapes = sample.map((row) => {
+        const paths = [];
+        let invalid = false;
+        const visit = (record, prefix) => {
+            for (const [key, item] of Object.entries(record)) {
+                if (key === '$jsonviews')
+                    continue;
+                const path = [...prefix, key];
+                if (isRecord(item) && prefix.length < 2)
+                    visit(item, path);
+                else if (item === null || isReadable(item))
+                    paths.push(path);
+                else
+                    invalid = true;
+                if (paths.length > 12) {
+                    invalid = true;
+                    return;
+                }
+            }
+        };
+        visit(row, []);
+        return invalid ? undefined : paths;
+    });
+    if (shapes.some((shape) => !shape))
+        return undefined;
+    const paths = shapes[0];
+    if (paths.length < 2 || !paths.some((path) => path.length > 1))
+        return undefined;
+    const shared = paths.filter((path) => shapes.every((shape) => shape.some((other) => JSON.stringify(path) === JSON.stringify(other))));
+    if (shared.length / Math.max(...shapes.map((shape) => shape.length)) < 0.8)
+        return undefined;
+    return shared;
+}

package/dist/type-registry.d.ts

@@ -0,0 +1,57 @@
+export declare const BUILT_IN_TYPE_NAMES: readonly ["text", "markdown", "html", "number", "checkbox", "select", "multi-select", "date", "url", "email", "body"];
+export type BuiltInTypeName = (typeof BUILT_IN_TYPE_NAMES)[number];
+/** Stable palette names understood by the built-in choice widgets. */
+export declare const JSON_VIEW_OPTION_COLORS: readonly ["gray", "blue", "green", "yellow", "orange", "red", "purple", "pink"];
+export type JsonViewOptionColor = (typeof JSON_VIEW_OPTION_COLORS)[number];
+export interface JsonViewTypeDescriptorLike {
+    type: string;
+    required?: boolean;
+    minimum?: number | string | null;
+    maximum?: number | string | null;
+    pattern?: string;
+    options?: string[];
+    optionColors?: Record<string, JsonViewOptionColor>;
+    [key: string]: unknown;
+}
+export interface JsonViewTypeDefinition<Descriptor extends JsonViewTypeDescriptorLike = JsonViewTypeDescriptorLike> {
+    name: string;
+    validate: (value: unknown, descriptor: Descriptor) => string | undefined;
+    warnings?: (value: unknown, descriptor: Descriptor) => string[];
+    /** Checks type-specific annotation fields before the descriptor can be used. */
+    validateDescriptor?: (descriptor: Descriptor) => string | undefined;
+    /** Converts persisted JSON to the editor model. Omitted hooks are identity. */
+    parse?: (value: unknown, descriptor: Descriptor) => unknown;
+    /** Converts an editor model to JSON, before canonical value validation. */
+    serialize?: (value: unknown, descriptor: Descriptor) => unknown;
+    compare?: (left: unknown, right: unknown, direction: 'asc' | 'desc') => number;
+    matchesFilter?: (value: unknown, operator: string, expected: unknown) => boolean | undefined;
+    filterOperators?: readonly string[];
+    /** Supported annotation keys for diagnostic help. Omit for an open extension vocabulary. */
+    descriptorProperties?: readonly string[];
+}
+export declare class JsonViewTypeRegistry {
+    private readonly definitions;
+    private readonly listeners;
+    private revision;
+    get version(): number;
+    subscribe: (listener: () => void) => (() => void);
+    private changed;
+    constructor(definitions?: readonly JsonViewTypeDefinition[]);
+    register(definition: JsonViewTypeDefinition): this;
+    unregister(name: string): this;
+    get(name: string): JsonViewTypeDefinition | undefined;
+    has(name: string): boolean;
+    names(): string[];
+    clone(): JsonViewTypeRegistry;
+    validateDescriptor(descriptor: JsonViewTypeDescriptorLike): string | undefined;
+    parse(value: unknown, descriptor: JsonViewTypeDescriptorLike): unknown;
+    serialize(value: unknown, descriptor: JsonViewTypeDescriptorLike): unknown;
+    validate(value: unknown, descriptor: JsonViewTypeDescriptorLike): string | undefined;
+    warnings(value: unknown, descriptor: JsonViewTypeDescriptorLike): string[];
+    compare(left: unknown, right: unknown, descriptor: JsonViewTypeDescriptorLike, direction: 'asc' | 'desc'): number | undefined;
+    matchesFilter(value: unknown, operator: string, expected: unknown, descriptor: JsonViewTypeDescriptorLike): boolean | undefined;
+    filterOperators(descriptor: JsonViewTypeDescriptorLike): readonly string[] | undefined;
+}
+export declare const dateTypeDefinition: JsonViewTypeDefinition;
+export declare function createDefaultTypeRegistry(): JsonViewTypeRegistry;
+export declare const defaultTypeRegistry: JsonViewTypeRegistry;

package/dist/type-registry.js

@@ -0,0 +1,238 @@
+import { DATE_FILTER_OPERATORS, compareDateValues, dateValueWarnings, matchesDateFilter, validateDateValue, } from './date-type.js';
+import { compileSafePattern } from './safe-pattern.js';
+import { BUILT_IN_DESCRIPTOR_PROPERTIES, COMMON_DESCRIPTOR_PROPERTIES } from './annotation-capabilities.js';
+export const BUILT_IN_TYPE_NAMES = [
+    'text',
+    'markdown',
+    'html',
+    'number',
+    'checkbox',
+    'select',
+    'multi-select',
+    'date',
+    'url',
+    'email',
+    'body',
+];
+/** Stable palette names understood by the built-in choice widgets. */
+export const JSON_VIEW_OPTION_COLORS = [
+    'gray', 'blue', 'green', 'yellow', 'orange', 'red', 'purple', 'pink',
+];
+function requireString(value) {
+    return typeof value === 'string' ? undefined : 'Value must be text';
+}
+export class JsonViewTypeRegistry {
+    definitions = new Map();
+    listeners = new Set();
+    revision = 0;
+    get version() { return this.revision; }
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    };
+    changed() {
+        this.revision += 1;
+        this.listeners.forEach((listener) => listener());
+    }
+    constructor(definitions = []) {
+        definitions.forEach((definition) => this.register(definition));
+    }
+    register(definition) {
+        if (typeof definition.name !== 'string' || !definition.name.trim())
+            throw new TypeError('A JSON Views type must have a name');
+        if (typeof definition.validate !== 'function')
+            throw new TypeError('A JSON Views type must provide validate');
+        if (definition.filterOperators?.some((operator) => typeof operator !== 'string' || !operator.trim())) {
+            throw new TypeError('Filter operators must be non-empty strings');
+        }
+        this.definitions.set(definition.name, Object.freeze({
+            ...definition,
+            ...(definition.filterOperators ? { filterOperators: Object.freeze([...definition.filterOperators]) } : {}),
+            ...(definition.descriptorProperties ? { descriptorProperties: Object.freeze([...definition.descriptorProperties]) } : {}),
+        }));
+        this.changed();
+        return this;
+    }
+    unregister(name) {
+        if (this.definitions.delete(name))
+            this.changed();
+        return this;
+    }
+    get(name) {
+        return this.definitions.get(name);
+    }
+    has(name) {
+        return this.definitions.has(name);
+    }
+    names() {
+        return [...this.definitions.keys()];
+    }
+    clone() {
+        return new JsonViewTypeRegistry([...this.definitions.values()]);
+    }
+    validateDescriptor(descriptor) {
+        try {
+            const issue = this.get(descriptor.type)?.validateDescriptor?.(descriptor);
+            return issue === undefined || typeof issue === 'string' ? issue : 'Descriptor validator must return a string or undefined';
+        }
+        catch (error) {
+            return `Descriptor validator failed: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    parse(value, descriptor) {
+        const parse = this.get(descriptor.type)?.parse;
+        return parse ? parse(value, descriptor) : value;
+    }
+    serialize(value, descriptor) {
+        const serialize = this.get(descriptor.type)?.serialize;
+        return serialize ? serialize(value, descriptor) : value;
+    }
+    validate(value, descriptor) {
+        if (value === undefined || value === null || (value === '' && descriptor.type !== 'date')) {
+            return descriptor.required === true ? 'A value is required' : undefined;
+        }
+        const definition = this.get(descriptor.type);
+        if (!definition)
+            return `Unknown type: ${descriptor.type}`;
+        try {
+            const issue = definition.validate(value, descriptor);
+            if (issue !== undefined && typeof issue !== 'string')
+                return 'Validator must return a string or undefined';
+            if (issue)
+                return issue;
+            if (typeof value === 'string' && descriptor.pattern !== undefined) {
+                if (!compileSafePattern(descriptor.pattern).matcher(value).find())
+                    return 'Value does not match the required pattern';
+            }
+        }
+        catch (error) {
+            return `Validation failed: ${error instanceof Error ? error.message : String(error)}`;
+        }
+        return undefined;
+    }
+    warnings(value, descriptor) {
+        try {
+            const warnings = this.get(descriptor.type)?.warnings?.(value, descriptor) ?? [];
+            return Array.isArray(warnings) && warnings.every((warning) => typeof warning === 'string')
+                ? warnings : ['Warning provider must return an array of strings'];
+        }
+        catch (error) {
+            return [`Warning provider failed: ${error instanceof Error ? error.message : String(error)}`];
+        }
+    }
+    compare(left, right, descriptor, direction) {
+        try {
+            const result = this.get(descriptor.type)?.compare?.(left, right, direction);
+            return typeof result === 'number' && Number.isFinite(result) ? result : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    matchesFilter(value, operator, expected, descriptor) {
+        try {
+            const matches = this.get(descriptor.type)?.matchesFilter?.(value, operator, expected);
+            return matches === undefined || typeof matches === 'boolean' ? matches : false;
+        }
+        catch {
+            return false;
+        }
+    }
+    filterOperators(descriptor) {
+        return this.get(descriptor.type)?.filterOperators;
+    }
+}
+const textType = { name: 'text', validate: requireString, serialize: (value) => value == null ? value : String(value) };
+const markdownType = { ...textType, name: 'markdown' };
+const htmlType = { ...textType, name: 'html' };
+const bodyType = { ...textType, name: 'body' };
+const numberType = {
+    name: 'number',
+    serialize: (value) => typeof value === 'string' ? value.trim() === '' ? null : Number(value) : value,
+    validate(value, descriptor) {
+        if (typeof value !== 'number' || !Number.isFinite(value))
+            return 'Value must be a finite number';
+        if (typeof descriptor.minimum === 'number' && value < descriptor.minimum)
+            return `Value must be at least ${descriptor.minimum}`;
+        if (typeof descriptor.maximum === 'number' && value > descriptor.maximum)
+            return `Value must be at most ${descriptor.maximum}`;
+        return undefined;
+    },
+};
+const checkboxType = {
+    name: 'checkbox',
+    serialize(value) {
+        if (value === true || value === 'true')
+            return true;
+        if (value === false || value === 'false')
+            return false;
+        return value;
+    },
+    validate: (value) => typeof value === 'boolean' ? undefined : 'Value must be true or false',
+};
+const selectType = {
+    name: 'select',
+    serialize: (value) => value === '' ? null : value,
+    validate(value) {
+        return typeof value === 'string' ? undefined : 'Value must be text';
+    },
+};
+const multiSelectType = {
+    name: 'multi-select',
+    serialize: (value) => typeof value === 'string' ? JSON.parse(value) : value,
+    validate(value) {
+        if (!Array.isArray(value) || !value.every((item) => typeof item === 'string')) {
+            return 'Value must be an array of text options';
+        }
+        return undefined;
+    },
+};
+export const dateTypeDefinition = {
+    name: 'date',
+    validate: (value, descriptor) => validateDateValue(value, descriptor),
+    warnings: dateValueWarnings,
+    compare: compareDateValues,
+    matchesFilter: matchesDateFilter,
+    filterOperators: DATE_FILTER_OPERATORS,
+};
+const urlType = {
+    name: 'url',
+    serialize: textType.serialize,
+    validate(value) {
+        if (typeof value !== 'string')
+            return 'Value must be a URL';
+        try {
+            const url = new URL(value);
+            return url.protocol === 'http:' || url.protocol === 'https:' ? undefined : 'Enter a valid web URL';
+        }
+        catch {
+            return 'Enter a valid web URL';
+        }
+    },
+};
+const emailType = {
+    name: 'email',
+    serialize: textType.serialize,
+    validate: (value) => typeof value === 'string' && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)
+        ? undefined
+        : 'Enter a valid email address',
+};
+export function createDefaultTypeRegistry() {
+    return new JsonViewTypeRegistry([
+        textType,
+        numberType,
+        checkboxType,
+        selectType,
+        multiSelectType,
+        dateTypeDefinition,
+        urlType,
+        emailType,
+        markdownType,
+        htmlType,
+        bodyType,
+    ].map((definition) => ({
+        ...definition,
+        descriptorProperties: [...COMMON_DESCRIPTOR_PROPERTIES, ...BUILT_IN_DESCRIPTOR_PROPERTIES[definition.name]],
+    })));
+}
+export const defaultTypeRegistry = createDefaultTypeRegistry();

package/dist/value-comparison.d.ts

@@ -0,0 +1,18 @@
+import type { ValuePath } from './json-path.js';
+/** Optional source tokens keep numeric comparisons independent of JS rounding. */
+export type JsonNumberLookup = (path?: ValuePath | null) => string | undefined;
+export interface JsonComparisonContext {
+    numberAtPath?: JsonNumberLookup;
+    leftPath?: ValuePath;
+    rightPath?: ValuePath;
+}
+/** Exact decimal ordering, including overflow/underflow and arbitrarily large exponents.
+ * Work is proportional to token length; exponents never cause zero-filled expansion.
+ */
+export declare function compareJsonNumberTokens(left: string, right: string): number;
+/** Total type ordering, then numeric/text/lexicographic container ordering. */
+export declare function compareJsonValues(left: unknown, right: unknown, context?: JsonComparisonContext): number;
+export declare function jsonValuesEqual(left: unknown, right: unknown, context?: JsonComparisonContext): boolean;
+/** Text conversion that never invokes a JSON object's own toString/valueOf. */
+export declare function jsonValueText(value: unknown): string;
+export declare function matchesJsonValueFilter(value: unknown, operator: string, expected?: unknown, context?: JsonComparisonContext): boolean;

package/dist/value-comparison.js

@@ -0,0 +1,133 @@
+import { assertJsonDepth } from './json-limits.js';
+const NUMBER = /^(-?)(0|[1-9][0-9]*)(?:\.([0-9]+))?(?:[eE]([+-]?[0-9]+))?$/;
+function decimal(token) {
+    const match = NUMBER.exec(token);
+    if (!match)
+        throw new TypeError('Expected a JSON number token');
+    const fraction = match[3] ?? '';
+    const digits = (match[2] + fraction).replace(/^0+/, '').replace(/0+$/, '');
+    const raw = (match[2] + fraction).replace(/^0+/, '');
+    return {
+        sign: digits ? (match[1] ? -1 : 1) : 0,
+        digits,
+        magnitude: BigInt(match[4] ?? '0') - BigInt(fraction.length) + BigInt(raw.length),
+    };
+}
+/** Exact decimal ordering, including overflow/underflow and arbitrarily large exponents.
+ * Work is proportional to token length; exponents never cause zero-filled expansion.
+ */
+export function compareJsonNumberTokens(left, right) {
+    const a = decimal(left), b = decimal(right);
+    if (a.sign !== b.sign)
+        return a.sign < b.sign ? -1 : 1;
+    if (!a.sign)
+        return 0;
+    if (a.magnitude !== b.magnitude)
+        return (a.magnitude < b.magnitude ? -1 : 1) * a.sign;
+    for (let index = 0; index < Math.max(a.digits.length, b.digits.length); index++) {
+        const l = a.digits[index] ?? '0', r = b.digits[index] ?? '0';
+        if (l !== r)
+            return (l < r ? -1 : 1) * a.sign;
+    }
+    return 0;
+}
+function rank(value) {
+    if (value === null)
+        return 5;
+    if (typeof value === 'boolean')
+        return 0;
+    if (typeof value === 'number')
+        return 1;
+    if (typeof value === 'string')
+        return 2;
+    if (Array.isArray(value))
+        return 3;
+    if (typeof value === 'object')
+        return 4;
+    return 6; // Missing values are last.
+}
+const child = (path, key) => path && [...path, key];
+function compare(left, right, context, strict) {
+    assertJsonDepth(left);
+    assertJsonDepth(right);
+    const pending = [{ left, right, context }];
+    while (pending.length) {
+        const { left: a, right: b, context: ctx } = pending.pop();
+        const ar = rank(a), br = rank(b);
+        if (ar !== br)
+            return ar < br ? -1 : 1;
+        if (typeof a === 'number' && typeof b === 'number') {
+            const at = ctx.numberAtPath?.(ctx.leftPath) ?? (Number.isFinite(a) ? String(a) : undefined);
+            const bt = ctx.numberAtPath?.(ctx.rightPath) ?? (Number.isFinite(b) ? String(b) : undefined);
+            const result = at !== undefined && bt !== undefined ? compareJsonNumberTokens(at, bt)
+                : Object.is(a, b) ? 0 : a < b ? -1 : 1;
+            if (result)
+                return result;
+        }
+        else if (typeof a === 'string' && typeof b === 'string') {
+            const result = strict ? (a === b ? 0 : a < b ? -1 : 1) : a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' });
+            if (result)
+                return result;
+        }
+        else if (typeof a === 'boolean' && typeof b === 'boolean') {
+            if (a !== b)
+                return a ? 1 : -1;
+        }
+        else if (a !== null && b !== null && typeof a === 'object' && typeof b === 'object') {
+            const ak = Array.isArray(a) ? a.map((_, index) => index) : Object.keys(a).sort();
+            const bk = Array.isArray(b) ? b.map((_, index) => index) : Object.keys(b).sort();
+            // Length is a final tie-break, after lexicographic key/value comparison.
+            pending.push({ left: ak.length, right: bk.length, context: {} });
+            for (let index = Math.min(ak.length, bk.length) - 1; index >= 0; index--) {
+                const key = ak[index], other = bk[index];
+                pending.push({ left: a[key], right: b[other],
+                    context: { ...ctx, leftPath: child(ctx.leftPath, key), rightPath: child(ctx.rightPath, other) } });
+                // Keys are JSON data too; never call methods supplied by an object.
+                pending.push({ left: key, right: other, context: {} });
+            }
+        }
+    }
+    return 0;
+}
+/** Total type ordering, then numeric/text/lexicographic container ordering. */
+export function compareJsonValues(left, right, context = {}) {
+    return compare(left, right, context, false);
+}
+export function jsonValuesEqual(left, right, context = {}) {
+    return compare(left, right, context, true) === 0;
+}
+/** Text conversion that never invokes a JSON object's own toString/valueOf. */
+export function jsonValueText(value) {
+    return value !== null && typeof value === 'object' ? JSON.stringify(value) : String(value);
+}
+export function matchesJsonValueFilter(value, operator, expected, context = {}) {
+    const empty = value === undefined || value === null || value === '' || (Array.isArray(value) && value.length === 0);
+    if (operator === 'isEmpty')
+        return empty;
+    if (operator === 'isNotEmpty')
+        return !empty;
+    const equal = (a, b, ctx = context) => jsonValuesEqual(a, b, ctx);
+    if (operator === 'eq')
+        return equal(value, expected);
+    if (operator === 'neq')
+        return !equal(value, expected);
+    if (operator === 'in' || operator === 'notIn') {
+        const found = Array.isArray(expected) && expected.some((candidate, index) => equal(value, candidate, { ...context, rightPath: child(context.rightPath, index) }));
+        return operator === 'in' ? found : !found;
+    }
+    if (operator === 'contains' || operator === 'notContains') {
+        const found = typeof value === 'string' ? value.toLocaleLowerCase().includes(jsonValueText(expected ?? '').toLocaleLowerCase())
+            : Array.isArray(value) && value.some((candidate, index) => equal(candidate, expected, { ...context, leftPath: child(context.leftPath, index) }));
+        return operator === 'contains' ? found : !found;
+    }
+    const ordered = compareJsonValues(value, expected, context);
+    if (operator === 'gt')
+        return ordered > 0;
+    if (operator === 'gte')
+        return ordered >= 0;
+    if (operator === 'lt')
+        return ordered < 0;
+    if (operator === 'lte')
+        return ordered <= 0;
+    return false;
+}

package/dist/view-model.d.ts

@@ -0,0 +1,18 @@
+import { type JsonComparisonContext, type JsonNumberLookup } from './value-comparison.js';
+import type { ValuePath } from './json-path.js';
+import { type CompiledJsonViewFilterRule, type CompiledJsonViewSchema, type CompiledJsonViewView, type JsonViewPath, type JsonViewViewRow } from './metadata.js';
+import { type JsonViewTypeRegistry } from './type-registry.js';
+export interface JsonViewDisplayColumn {
+    id: string;
+    label: string;
+    path: JsonViewPath;
+}
+export interface JsonViewProjectedCollection {
+    rows: JsonViewViewRow[];
+    columns: JsonViewDisplayColumn[];
+    records: Record<string, unknown>[];
+}
+export declare function matchesJsonViewFilterRule(value: unknown, rule: CompiledJsonViewFilterRule, descriptor?: CompiledJsonViewSchema['descriptor'], typeRegistry?: JsonViewTypeRegistry, context?: JsonComparisonContext): boolean;
+export declare function applyJsonViewViewRows(root: unknown, view: CompiledJsonViewView, schema?: readonly CompiledJsonViewSchema[], typeRegistry?: JsonViewTypeRegistry, numberAtPath?: JsonNumberLookup): JsonViewViewRow[];
+export declare function projectJsonViewCollection(root: unknown, view: CompiledJsonViewView, schema?: readonly CompiledJsonViewSchema[], typeRegistry?: JsonViewTypeRegistry, numberAtPath?: JsonNumberLookup): JsonViewProjectedCollection;
+export declare function schemaRelativePathForRow(schema: CompiledJsonViewSchema, rowPath: ValuePath): ValuePath | undefined;