@svgrid/grid 1.1.0 → 1.1.1

package/dist/editors/cell-editors.coverage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/editors/cell-editors.coverage.test.js

@@ -0,0 +1,139 @@
+import { describe, expect, it } from 'vitest';
+import { normalizeEditorOptions, parseEditorValue } from './cell-editors';
+describe('normalizeEditorOptions', () => {
+    it('returns [] for undefined', () => {
+        expect(normalizeEditorOptions(undefined)).toEqual([]);
+    });
+    it('treats a function (mistakenly passed) as empty', () => {
+        // The type says functions are resolved earlier, but the guard handles it.
+        const fn = (() => []);
+        expect(normalizeEditorOptions(fn)).toEqual([]);
+    });
+    it('maps bare strings to { value, label }', () => {
+        expect(normalizeEditorOptions(['a', 'b'])).toEqual([
+            { value: 'a', label: 'a' },
+            { value: 'b', label: 'b' },
+        ]);
+    });
+    it('maps bare numbers to stringified labels', () => {
+        expect(normalizeEditorOptions([1, 2])).toEqual([
+            { value: 1, label: '1' },
+            { value: 2, label: '2' },
+        ]);
+    });
+    it('keeps an explicit label and color', () => {
+        expect(normalizeEditorOptions([{ value: 'x', label: 'Ex', color: '#f00' }])).toEqual([{ value: 'x', label: 'Ex', color: '#f00' }]);
+    });
+    it('defaults a missing label to String(value)', () => {
+        expect(normalizeEditorOptions([{ value: 7 }])).toEqual([
+            { value: 7, label: '7', color: undefined },
+        ]);
+    });
+});
+describe('parseEditorValue - rating', () => {
+    it('rounds and clamps into 0..5', () => {
+        expect(parseEditorValue('rating', 3.4)).toBe(3);
+        expect(parseEditorValue('rating', 4.6)).toBe(5);
+        expect(parseEditorValue('rating', 9)).toBe(5);
+        expect(parseEditorValue('rating', -2)).toBe(0);
+    });
+    it('returns 0 for non-finite input', () => {
+        expect(parseEditorValue('rating', 'nope')).toBe(0);
+        expect(parseEditorValue('rating', Infinity)).toBe(0);
+    });
+});
+describe('parseEditorValue - color', () => {
+    it('returns the trimmed color string', () => {
+        expect(parseEditorValue('color', '  #abcdef  ')).toBe('#abcdef');
+    });
+    it('passes non-hex color strings through', () => {
+        expect(parseEditorValue('color', 'rebeccapurple')).toBe('rebeccapurple');
+    });
+    it('falls back to #000000 for empty/nullish', () => {
+        expect(parseEditorValue('color', '')).toBe('#000000');
+        expect(parseEditorValue('color', null)).toBe('#000000');
+        expect(parseEditorValue('color', undefined)).toBe('#000000');
+    });
+});
+describe('parseEditorValue - time', () => {
+    it('returns null for empty input', () => {
+        expect(parseEditorValue('time', '')).toBe(null);
+        expect(parseEditorValue('time', null)).toBe(null);
+    });
+    it('returns null for malformed strings', () => {
+        expect(parseEditorValue('time', 'noon')).toBe(null);
+        expect(parseEditorValue('time', '12')).toBe(null);
+    });
+    it('normalizes HH:MM', () => {
+        expect(parseEditorValue('time', '9:05')).toBe('09:05');
+    });
+    it('keeps seconds when present', () => {
+        expect(parseEditorValue('time', '23:59:59')).toBe('23:59:59');
+    });
+    it('clamps out-of-range components', () => {
+        expect(parseEditorValue('time', '99:99:99')).toBe('23:59:59');
+    });
+});
+describe('parseEditorValue - password', () => {
+    it('keeps an empty string instead of nulling it', () => {
+        expect(parseEditorValue('password', '')).toBe('');
+    });
+    it('stringifies and preserves content', () => {
+        expect(parseEditorValue('password', 'hunter2')).toBe('hunter2');
+        expect(parseEditorValue('password', null)).toBe('');
+    });
+});
+describe('parseEditorValue - select / rich-select', () => {
+    it('returns scalar value as-is', () => {
+        expect(parseEditorValue('select', 'one')).toBe('one');
+        expect(parseEditorValue('rich-select', 5)).toBe(5);
+    });
+    it('takes the first element of an array', () => {
+        expect(parseEditorValue('select', ['a', 'b'])).toBe('a');
+    });
+    it('coerces nullish to null', () => {
+        expect(parseEditorValue('select', null)).toBe(null);
+        expect(parseEditorValue('select', undefined)).toBe(null);
+        expect(parseEditorValue('rich-select', [])).toBe(null);
+    });
+});
+describe('parseEditorValue - textarea', () => {
+    it('stringifies, nullish to empty', () => {
+        expect(parseEditorValue('textarea', 'multi\nline')).toBe('multi\nline');
+        expect(parseEditorValue('textarea', null)).toBe('');
+    });
+});
+describe('parseEditorValue - list / chips (single)', () => {
+    it('returns scalar as-is', () => {
+        expect(parseEditorValue('list', 'x')).toBe('x');
+        expect(parseEditorValue('chips', 7)).toBe(7);
+    });
+    it('takes first element of array', () => {
+        expect(parseEditorValue('list', ['a', 'b'])).toBe('a');
+        expect(parseEditorValue('chips', [])).toBe(null);
+    });
+    it('coerces nullish to null', () => {
+        expect(parseEditorValue('list', null)).toBe(null);
+    });
+});
+describe('parseEditorValue - list / chips (multiple)', () => {
+    it('clones an array', () => {
+        const input = ['a', 'b'];
+        const out = parseEditorValue('list', input, { multiple: true });
+        expect(out).toEqual(['a', 'b']);
+        expect(out).not.toBe(input);
+    });
+    it('returns [] for empty/nullish', () => {
+        expect(parseEditorValue('chips', null, { multiple: true })).toEqual([]);
+        expect(parseEditorValue('chips', '', { multiple: true })).toEqual([]);
+    });
+    it('wraps a scalar into a single-element array', () => {
+        expect(parseEditorValue('list', 'solo', { multiple: true })).toEqual(['solo']);
+    });
+});
+describe('parseEditorValue - unknown type fallback', () => {
+    it('stringifies, nullish to empty', () => {
+        expect(parseEditorValue('autocomplete', 'hey')).toBe('hey');
+        expect(parseEditorValue('autocomplete', undefined)).toBe('');
+    });
+});

package/dist/facet-buckets.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/facet-buckets.test.js

@@ -0,0 +1,296 @@
+/**
+ * Unit tests for the facet value-bucketing helpers: isBucketableColumn,
+ * buildBuckets, isInBucket. These are pure functions - the only grid
+ * coupling is the Column type (we use createSvGrid to mint real columns
+ * carrying an `editorType`) and the rawToNumber/format helpers.
+ */
+import { describe, expect, it } from 'vitest';
+import { createCoreRowModel, createSvGrid, tableFeatures, rowSortingFeature, } from './index';
+import { isBucketableColumn, buildBuckets, isInBucket, } from './facet-buckets';
+const features = tableFeatures({ rowSortingFeature });
+/** Build a real grid and return its columns keyed by id so tests can grab
+ *  a genuine Column<Row> object (with columnDef.editorType populated). */
+function makeColumns() {
+    const columns = [
+        { field: 'id', header: 'ID', editorType: 'text' },
+        { field: 'num', header: 'Number', editorType: 'number' },
+        { field: 'when', header: 'When', editorType: 'date' },
+        { field: 'name', header: 'Name' }, // no editorType
+        { field: 'flag', header: 'Flag', editorType: 'checkbox' },
+    ];
+    const grid = createSvGrid({
+        _features: features,
+        _rowModels: { coreRowModel: createCoreRowModel() },
+        columns,
+        data: [],
+    });
+    const byId = {};
+    for (const c of grid.getAllColumns())
+        byId[c.id] = c;
+    return byId;
+}
+// Field accessor used by buildBuckets in production - read the property
+// matching the column id off the row.
+function accessor(row, column) {
+    return row[column.id];
+}
+describe('isBucketableColumn', () => {
+    const cols = makeColumns();
+    it('returns { isDate: false } for a number column', () => {
+        expect(isBucketableColumn(cols.num)).toEqual({ isDate: false });
+    });
+    it('returns { isDate: true } for a date column', () => {
+        expect(isBucketableColumn(cols.when)).toEqual({ isDate: true });
+    });
+    it('returns { isDate: true } for a datetime column', () => {
+        const grid = createSvGrid({
+            _features: features,
+            _rowModels: { coreRowModel: createCoreRowModel() },
+            columns: [{ field: 'when', header: 'When', editorType: 'datetime' }],
+            data: [],
+        });
+        const col = grid.getAllColumns().find((c) => c.id === 'when');
+        expect(isBucketableColumn(col)).toEqual({ isDate: true });
+    });
+    it('returns null for a text column', () => {
+        expect(isBucketableColumn(cols.id)).toBeNull();
+    });
+    it('returns null for a checkbox column', () => {
+        expect(isBucketableColumn(cols.flag)).toBeNull();
+    });
+    it('returns null for a column with no editorType', () => {
+        expect(isBucketableColumn(cols.name)).toBeNull();
+    });
+});
+describe('buildBuckets - numeric', () => {
+    const cols = makeColumns();
+    it('returns null when distinct values do not exceed the threshold (30)', () => {
+        // 30 distinct values -> not > 30 -> null
+        const data = Array.from({ length: 30 }, (_, i) => ({
+            id: String(i),
+            num: i,
+            when: '',
+            name: '',
+            flag: false,
+        }));
+        expect(buildBuckets(cols.num, false, data, accessor)).toBeNull();
+    });
+    it('builds 10 buckets when distinct values exceed the threshold', () => {
+        // 31 distinct values 0..30 -> > 30 -> buckets
+        const data = Array.from({ length: 31 }, (_, i) => ({
+            id: String(i),
+            num: i,
+            when: '',
+            name: '',
+            flag: false,
+        }));
+        const buckets = buildBuckets(cols.num, false, data, accessor);
+        expect(buckets).not.toBeNull();
+        expect(buckets).toHaveLength(10);
+    });
+    it('spans the full numeric range with contiguous edges', () => {
+        const data = Array.from({ length: 31 }, (_, i) => ({
+            id: String(i),
+            num: i, // 0..30
+            when: '',
+            name: '',
+            flag: false,
+        }));
+        const buckets = buildBuckets(cols.num, false, data, accessor);
+        expect(buckets[0].numericMin).toBe(0);
+        expect(buckets[9].numericMax).toBe(30);
+        // bucket i's max equals bucket i+1's min (contiguous, no gaps)
+        for (let i = 0; i < buckets.length - 1; i += 1) {
+            expect(buckets[i].numericMax).toBeCloseTo(buckets[i + 1].numericMin, 10);
+        }
+    });
+    it('flags only the final bucket as isLast and sets isDate=false', () => {
+        const data = Array.from({ length: 31 }, (_, i) => ({
+            id: String(i),
+            num: i,
+            when: '',
+            name: '',
+            flag: false,
+        }));
+        const buckets = buildBuckets(cols.num, false, data, accessor);
+        expect(buckets.filter((b) => b.isLast)).toHaveLength(1);
+        expect(buckets[9].isLast).toBe(true);
+        expect(buckets[0].isLast).toBe(false);
+        expect(buckets.every((b) => b.isDate === false)).toBe(true);
+    });
+    it('uses numeric labels containing an en-dash separator', () => {
+        const data = Array.from({ length: 31 }, (_, i) => ({
+            id: String(i),
+            num: i,
+            when: '',
+            name: '',
+            flag: false,
+        }));
+        const buckets = buildBuckets(cols.num, false, data, accessor);
+        expect(buckets[0].label).toContain('–');
+    });
+    it('ignores non-finite / blank values when computing min/max and distinct', () => {
+        // 31 numeric values plus a pile of null/undefined/empty/NaN-ish ones
+        const data = [
+            ...Array.from({ length: 31 }, (_, i) => ({
+                id: String(i),
+                num: i,
+                when: '',
+                name: '',
+                flag: false,
+            })),
+            { id: 'a', num: null, when: '', name: '', flag: false },
+            { id: 'b', num: undefined, when: '', name: '', flag: false },
+            { id: 'c', num: 'not-a-number', when: '', name: '', flag: false },
+        ];
+        const buckets = buildBuckets(cols.num, false, data, accessor);
+        // range is still 0..30 - the junk rows were skipped
+        expect(buckets[0].numericMin).toBe(0);
+        expect(buckets[9].numericMax).toBe(30);
+    });
+    it('returns null when all finite values are identical (min === max)', () => {
+        // 40 rows but every num is 5 -> distinct.size === 1 -> <= threshold -> null.
+        // (Also exercises the min === max guard via a distinct-but-uniform case below.)
+        const data = Array.from({ length: 40 }, (_, i) => ({
+            id: String(i),
+            num: 5,
+            when: '',
+            name: '',
+            flag: false,
+        }));
+        expect(buildBuckets(cols.num, false, data, accessor)).toBeNull();
+    });
+    it('returns null when there is no finite data at all', () => {
+        const data = Array.from({ length: 40 }, (_, i) => ({
+            id: String(i),
+            num: null,
+            when: '',
+            name: '',
+            flag: false,
+        }));
+        expect(buildBuckets(cols.num, false, data, accessor)).toBeNull();
+    });
+    it('returns null for an empty dataset', () => {
+        expect(buildBuckets(cols.num, false, [], accessor)).toBeNull();
+    });
+    it('handles negative ranges', () => {
+        const data = Array.from({ length: 41 }, (_, i) => ({
+            id: String(i),
+            num: i - 20, // -20..20, 41 distinct
+            when: '',
+            name: '',
+            flag: false,
+        }));
+        const buckets = buildBuckets(cols.num, false, data, accessor);
+        expect(buckets[0].numericMin).toBe(-20);
+        expect(buckets[9].numericMax).toBe(20);
+    });
+});
+describe('buildBuckets - date', () => {
+    const cols = makeColumns();
+    it('builds buckets from date strings with isDate=true and date labels', () => {
+        const start = Date.UTC(2020, 0, 1);
+        const day = 24 * 60 * 60 * 1000;
+        const data = Array.from({ length: 40 }, (_, i) => ({
+            id: String(i),
+            num: 0,
+            when: new Date(start + i * day).toISOString(),
+            name: '',
+            flag: false,
+        }));
+        const buckets = buildBuckets(cols.when, true, data, accessor);
+        expect(buckets).toHaveLength(10);
+        expect(buckets.every((b) => b.isDate === true)).toBe(true);
+        // labels should look like dates (contain a 4-digit year)
+        expect(buckets[0].label).toMatch(/\d{4}/);
+    });
+    it('accepts Date instances directly', () => {
+        const start = Date.UTC(2020, 0, 1);
+        const day = 24 * 60 * 60 * 1000;
+        const data = Array.from({ length: 40 }, (_, i) => ({ id: 'when' + i, when: new Date(start + i * day) }));
+        // accessor reads row[column.id]; column id is 'when'
+        const rows = data.map((d) => ({ when: d.when }));
+        const buckets = buildBuckets(cols.when, true, rows, accessor);
+        expect(buckets).toHaveLength(10);
+        expect(buckets[0].numericMin).toBe(start);
+    });
+    it('returns null when date values are too few', () => {
+        const data = Array.from({ length: 5 }, (_, i) => ({
+            id: String(i),
+            num: 0,
+            when: new Date(Date.UTC(2020, 0, 1 + i)).toISOString(),
+            name: '',
+            flag: false,
+        }));
+        expect(buildBuckets(cols.when, true, data, accessor)).toBeNull();
+    });
+    it('skips invalid date strings', () => {
+        const start = Date.UTC(2021, 0, 1);
+        const day = 24 * 60 * 60 * 1000;
+        const data = [
+            ...Array.from({ length: 40 }, (_, i) => ({
+                id: String(i),
+                num: 0,
+                when: new Date(start + i * day).toISOString(),
+                name: '',
+                flag: false,
+            })),
+            { id: 'bad', num: 0, when: 'not-a-date', name: '', flag: false },
+        ];
+        const buckets = buildBuckets(cols.when, true, data, accessor);
+        expect(buckets).toHaveLength(10);
+        expect(buckets[0].numericMin).toBe(start);
+    });
+});
+describe('isInBucket', () => {
+    const mid = {
+        label: '10 - 20',
+        numericMin: 10,
+        numericMax: 20,
+        isLast: false,
+        isDate: false,
+    };
+    const last = {
+        label: '20 - 30',
+        numericMin: 20,
+        numericMax: 30,
+        isLast: true,
+        isDate: false,
+    };
+    it('returns false for non-finite numbers', () => {
+        expect(isInBucket(Number.NaN, mid)).toBe(false);
+        expect(isInBucket(Number.POSITIVE_INFINITY, mid)).toBe(false);
+    });
+    it('returns false below the lower bound', () => {
+        expect(isInBucket(9.999, mid)).toBe(false);
+    });
+    it('includes the lower bound', () => {
+        expect(isInBucket(10, mid)).toBe(true);
+    });
+    it('excludes the upper bound for a non-last bucket (half-open interval)', () => {
+        expect(isInBucket(20, mid)).toBe(false);
+        expect(isInBucket(19.999, mid)).toBe(true);
+    });
+    it('includes the upper bound for the last bucket (closed interval)', () => {
+        expect(isInBucket(30, last)).toBe(true);
+        expect(isInBucket(20, last)).toBe(true);
+    });
+    it('rejects values past the upper bound even on the last bucket', () => {
+        expect(isInBucket(30.0001, last)).toBe(false);
+    });
+    it('partitions a value into exactly one bucket across a built set', () => {
+        const cols = makeColumns();
+        const data = Array.from({ length: 101 }, (_, i) => ({
+            id: String(i),
+            num: i, // 0..100
+            when: '',
+            name: '',
+            flag: false,
+        }));
+        const buckets = buildBuckets(cols.num, false, data, accessor);
+        for (const v of [0, 1, 15, 50, 99, 100]) {
+            const hits = buckets.filter((b) => isInBucket(v, b));
+            expect(hits).toHaveLength(1);
+        }
+    });
+});

package/dist/filter-operators.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/filter-operators.test.js

@@ -0,0 +1,135 @@
+import { describe, expect, it } from "vitest";
+import { filterOperatorOptions, fallbackOperatorOption, TEXT_OPERATORS, NUMBER_OPERATORS, DATE_OPERATORS, CHECKBOX_OPERATORS, operatorOption, operatorsForColumn, defaultOperatorFor, operatorLabelFor, } from "./filter-operators";
+// `operatorsForColumn` / `defaultOperatorFor` / `operatorLabelFor` only ever
+// read `column?.columnDef.editorType`, so a minimal duck-typed stub is enough
+// to exercise every branch without standing up a real grid/column instance.
+function col(editorType) {
+    return editorType === undefined
+        ? { columnDef: {} }
+        : { columnDef: { editorType } };
+}
+describe("filter-operators: catalogue integrity", () => {
+    it("every option exposes value/label/iconName and a unique value", () => {
+        const values = filterOperatorOptions.map((o) => o.value);
+        expect(new Set(values).size).toBe(values.length);
+        for (const o of filterOperatorOptions) {
+            expect(typeof o.value).toBe("string");
+            expect(typeof o.label).toBe("string");
+            expect(o.iconName).toMatch(/^op-/);
+        }
+    });
+    it("fallback option is the 'contains' operator", () => {
+        expect(fallbackOperatorOption.value).toBe("contains");
+        expect(fallbackOperatorOption.label).toBe("Contains");
+    });
+    it("each type's operator list only references catalogued operators", () => {
+        const known = new Set(filterOperatorOptions.map((o) => o.value));
+        for (const list of [
+            TEXT_OPERATORS,
+            NUMBER_OPERATORS,
+            DATE_OPERATORS,
+            CHECKBOX_OPERATORS,
+        ]) {
+            for (const id of list)
+                expect(known.has(id)).toBe(true);
+        }
+    });
+    it("the catalogue includes between / isBlank for numeric + date filtering", () => {
+        const values = filterOperatorOptions.map((o) => o.value);
+        expect(values).toContain("between");
+        expect(values).toContain("isBlank");
+    });
+});
+describe("operatorOption", () => {
+    it("returns the matching option for every catalogued operator", () => {
+        for (const o of filterOperatorOptions) {
+            expect(operatorOption(o.value)).toBe(o);
+        }
+    });
+    it("looks up a specific operator by value", () => {
+        expect(operatorOption("between")).toMatchObject({
+            value: "between",
+            label: "Between",
+        });
+        expect(operatorOption("greaterThan").label).toBe("Greater than");
+        expect(operatorOption("lessThan").label).toBe("Less than");
+        expect(operatorOption("startsWith").label).toBe("Starts with");
+    });
+    it("falls back to 'contains' for an unknown operator value", () => {
+        const result = operatorOption("nope");
+        expect(result).toBe(fallbackOperatorOption);
+        expect(result.value).toBe("contains");
+    });
+});
+describe("operatorsForColumn", () => {
+    const labels = (opts) => opts.map((o) => o.value);
+    it("number columns get equals/greaterThan/lessThan/between/isBlank", () => {
+        expect(labels(operatorsForColumn(col("number")))).toEqual(NUMBER_OPERATORS);
+    });
+    it("date columns get the date operator set", () => {
+        expect(labels(operatorsForColumn(col("date")))).toEqual(DATE_OPERATORS);
+    });
+    it("datetime columns share the date operator set", () => {
+        expect(labels(operatorsForColumn(col("datetime")))).toEqual(DATE_OPERATORS);
+    });
+    it("checkbox columns get only equals + isBlank", () => {
+        expect(labels(operatorsForColumn(col("checkbox")))).toEqual(CHECKBOX_OPERATORS);
+    });
+    it("text columns get the text operator set", () => {
+        expect(labels(operatorsForColumn(col("text")))).toEqual(TEXT_OPERATORS);
+    });
+    it("an unknown editor type defaults to the text operator set", () => {
+        expect(labels(operatorsForColumn(col("currency")))).toEqual(TEXT_OPERATORS);
+    });
+    it("a column with no editorType defaults to text", () => {
+        expect(labels(operatorsForColumn(col()))).toEqual(TEXT_OPERATORS);
+    });
+    it("an undefined column defaults to the text operator set", () => {
+        expect(labels(operatorsForColumn(undefined))).toEqual(TEXT_OPERATORS);
+    });
+    it("returns full FilterOption objects (value+label+iconName), in order", () => {
+        const opts = operatorsForColumn(col("number"));
+        expect(opts[0]).toMatchObject({ value: "equals", iconName: "op-equals" });
+        for (const o of opts) {
+            expect(o).toHaveProperty("label");
+            expect(o).toHaveProperty("iconName");
+        }
+    });
+});
+describe("defaultOperatorFor", () => {
+    it("picks the first operator valid for the column type", () => {
+        expect(defaultOperatorFor(col("number"))).toBe("equals");
+        expect(defaultOperatorFor(col("date"))).toBe("equals");
+        expect(defaultOperatorFor(col("checkbox"))).toBe("equals");
+        expect(defaultOperatorFor(col("text"))).toBe("contains");
+    });
+    it("defaults to 'contains' for text / unknown / undefined columns", () => {
+        expect(defaultOperatorFor(col())).toBe("contains");
+        expect(defaultOperatorFor(undefined)).toBe("contains");
+        expect(defaultOperatorFor(col("mystery"))).toBe("contains");
+    });
+});
+describe("operatorLabelFor", () => {
+    const less = operatorOption("lessThan");
+    const greater = operatorOption("greaterThan");
+    const equals = operatorOption("equals");
+    it("renames lessThan/greaterThan to Before/After for date columns", () => {
+        expect(operatorLabelFor(less, col("date"))).toBe("Before");
+        expect(operatorLabelFor(greater, col("date"))).toBe("After");
+    });
+    it("applies the date relabelling for datetime columns too", () => {
+        expect(operatorLabelFor(less, col("datetime"))).toBe("Before");
+        expect(operatorLabelFor(greater, col("datetime"))).toBe("After");
+    });
+    it("leaves non-relabelled operators untouched on date columns", () => {
+        expect(operatorLabelFor(equals, col("date"))).toBe(equals.label);
+    });
+    it("keeps the catalogue label for non-date columns", () => {
+        expect(operatorLabelFor(less, col("number"))).toBe("Less than");
+        expect(operatorLabelFor(greater, col("number"))).toBe("Greater than");
+        expect(operatorLabelFor(less, col("text"))).toBe("Less than");
+    });
+    it("keeps the catalogue label when the column is undefined", () => {
+        expect(operatorLabelFor(greater, undefined)).toBe("Greater than");
+    });
+});

package/dist/hyperformula-adapter.test.d.ts

@@ -0,0 +1 @@
+export {};