@cccsaurora/howler-ui 2.19.0-cases.863 → 2.19.0-dev.1000

package/utils/menuUtils.test.js

@@ -0,0 +1,198 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import AppMenuBuilder from './menuUtils';
+// Avoid pulling in react-pluggable (and its transitive React deps) by mocking the store module.
+// vi.mock is hoisted by Vitest before any imports, so the mock is applied even though this call appears below the imports.
+vi.mock('plugins/store', () => ({
+    MainMenuInsertOperation: {
+        Insert: 'INSERT',
+        InsertAfter: 'AFTER',
+        InsertBefore: 'BEFORE'
+    }
+}));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const makeItem = (id, overrides = {}) => ({
+    type: 'item',
+    element: { id, i18nKey: `key.${id}`, route: `/${id}`, ...overrides }
+});
+const makeGroup = (id, items = []) => ({
+    type: 'group',
+    element: { id, i18nKey: `key.${id}`, items }
+});
+const makeDivider = () => ({ type: 'divider', element: null });
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('AppMenuBuilder', () => {
+    let initial;
+    let builder;
+    beforeEach(() => {
+        initial = [makeItem('home'), makeItem('search'), makeGroup('tools', [{ id: 'view', route: '/view' }])];
+        builder = new AppMenuBuilder(initial);
+    });
+    // -------------------------------------------------------------------------
+    // menu getter
+    // -------------------------------------------------------------------------
+    describe('menu getter', () => {
+        it('returns the initial menu unchanged when no operations are applied', () => {
+            expect(builder.menu).toHaveLength(3);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // indexOfMenuId
+    // -------------------------------------------------------------------------
+    describe('indexOfMenuId', () => {
+        it('returns index -1 for the "root" pseudo-target', () => {
+            expect(builder.indexOfMenuId('root')).toEqual({ index: -1 });
+        });
+        it('returns the correct top-level index for a root item', () => {
+            expect(builder.indexOfMenuId('home')).toEqual({ index: 0 });
+        });
+        it('returns both index and subIndex for a nested item', () => {
+            expect(builder.indexOfMenuId('view')).toEqual({ index: 2, subIndex: 0 });
+        });
+        it('throws for an unknown id', () => {
+            expect(() => builder.indexOfMenuId('unknown-id')).toThrow();
+        });
+    });
+    // -------------------------------------------------------------------------
+    // insert
+    // -------------------------------------------------------------------------
+    describe('insert', () => {
+        it('appends a new item to the root when targetId is "root"', () => {
+            builder.insert('root', makeItem('new'));
+            expect(builder.menu).toHaveLength(4);
+            expect(builder.menu[3].element.id).toBe('new');
+        });
+        it('appends a new item to an existing group', () => {
+            builder.insert('tools', makeItem('extra'));
+            const group = builder.menu.find(el => el.type === 'group');
+            expect(group.element.items).toHaveLength(2);
+            expect(group.element.items[1].id).toBe('extra');
+        });
+        it('converts a root-level item into a group when inserting into it', () => {
+            builder.insert('home', makeItem('sub-home'));
+            const converted = builder.menu.find(el => el.type === 'group');
+            // The first group found should be the newly converted one.
+            expect(converted).toBeDefined();
+            expect(converted.element.items.some((i) => i.id === 'sub-home')).toBe(true);
+        });
+        it('marks nested items added to a group as nested:true', () => {
+            builder.insert('tools', makeItem('nested-item'));
+            const group = builder.menu.find(el => el.type === 'group');
+            const last = group.element.items[group.element.items.length - 1];
+            expect(last.nested).toBe(true);
+        });
+        it('does not insert a divider into a group (logs warning and returns)', () => {
+            const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+            const before = builder.menu.find(el => el.type === 'group').element.items.length;
+            builder.insert('tools', makeDivider());
+            const after = builder.menu.find(el => el.type === 'group').element.items.length;
+            expect(after).toBe(before);
+            warnSpy.mockRestore();
+        });
+    });
+    // -------------------------------------------------------------------------
+    // insertBefore
+    // -------------------------------------------------------------------------
+    describe('insertBefore', () => {
+        it('inserts a new root-level item before the target', () => {
+            builder.insertBefore('search', makeItem('before-search'));
+            // 'search' was at index 1; the new item should now be at index 1.
+            expect(builder.menu[1].element.id).toBe('before-search');
+            expect(builder.menu[2].element.id).toBe('search');
+        });
+        it('inserts before the first root item (index 0)', () => {
+            builder.insertBefore('home', makeItem('new-first'));
+            expect(builder.menu[0].element.id).toBe('new-first');
+        });
+        it('inserts a new nested item before a sub-item within its group', () => {
+            builder.insertBefore('view', makeItem('before-view'));
+            const group = builder.menu.find(el => el.type === 'group');
+            expect(group.element.items[0].id).toBe('before-view');
+            expect(group.element.items[1].id).toBe('view');
+        });
+        it('marks items inserted into a group as nested:true', () => {
+            builder.insertBefore('view', makeItem('nested-before'));
+            const group = builder.menu.find(el => el.type === 'group');
+            expect(group.element.items[0].nested).toBe(true);
+        });
+        it('does not insert a divider before a sub-item (logs warning)', () => {
+            const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+            const before = builder.menu.find(el => el.type === 'group').element.items.length;
+            builder.insertBefore('view', makeDivider());
+            const after = builder.menu.find(el => el.type === 'group').element.items.length;
+            expect(after).toBe(before);
+            warnSpy.mockRestore();
+        });
+    });
+    // -------------------------------------------------------------------------
+    // insertAfter
+    // -------------------------------------------------------------------------
+    describe('insertAfter', () => {
+        it('inserts a new root-level item after the target', () => {
+            builder.insertAfter('home', makeItem('after-home'));
+            expect(builder.menu[1].element.id).toBe('after-home');
+            expect(builder.menu[2].element.id).toBe('search');
+        });
+        it('inserts after the last root item', () => {
+            builder.insertAfter('tools', makeItem('very-last'));
+            expect(builder.menu[builder.menu.length - 1].element.id).toBe('very-last');
+        });
+        it('inserts a new nested item after a sub-item within its group', () => {
+            builder.insertAfter('view', makeItem('after-view'));
+            const group = builder.menu.find(el => el.type === 'group');
+            expect(group.element.items[0].id).toBe('view');
+            expect(group.element.items[1].id).toBe('after-view');
+        });
+        it('marks items inserted into a group as nested:true', () => {
+            builder.insertAfter('view', makeItem('nested-after'));
+            const group = builder.menu.find(el => el.type === 'group');
+            expect(group.element.items[1].nested).toBe(true);
+        });
+        it('does not insert a divider after a sub-item (logs warning)', () => {
+            const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+            const before = builder.menu.find(el => el.type === 'group').element.items.length;
+            builder.insertAfter('view', makeDivider());
+            const after = builder.menu.find(el => el.type === 'group').element.items.length;
+            expect(after).toBe(before);
+            warnSpy.mockRestore();
+        });
+    });
+    // -------------------------------------------------------------------------
+    // applyOperations
+    // -------------------------------------------------------------------------
+    describe('applyOperations', () => {
+        it('applies an INSERT operation to the root', () => {
+            builder.applyOperations([{ operation: 'INSERT', targetId: 'root', item: makeItem('op-item') }]);
+            expect(builder.menu.some((el) => el.element?.id === 'op-item')).toBe(true);
+        });
+        it('applies a BEFORE operation', () => {
+            builder.applyOperations([{ operation: 'BEFORE', targetId: 'search', item: makeItem('before-op') }]);
+            const idx = builder.menu.findIndex((el) => el.element?.id === 'before-op');
+            const searchIdx = builder.menu.findIndex((el) => el.element?.id === 'search');
+            expect(idx).toBeLessThan(searchIdx);
+        });
+        it('applies an AFTER operation', () => {
+            builder.applyOperations([{ operation: 'AFTER', targetId: 'home', item: makeItem('after-op') }]);
+            const homeIdx = builder.menu.findIndex((el) => el.element?.id === 'home');
+            const afterIdx = builder.menu.findIndex((el) => el.element?.id === 'after-op');
+            expect(afterIdx).toBe(homeIdx + 1);
+        });
+        it('applies multiple operations in order', () => {
+            builder.applyOperations([
+                { operation: 'INSERT', targetId: 'root', item: makeItem('first') },
+                { operation: 'INSERT', targetId: 'root', item: makeItem('second') }
+            ]);
+            const ids = builder.menu.map((el) => el.element?.id).filter(Boolean);
+            expect(ids).toContain('first');
+            expect(ids).toContain('second');
+        });
+        it('ignores operations with unknown operation strings', () => {
+            const lenBefore = builder.menu.length;
+            builder.applyOperations([{ operation: 'UNKNOWN', targetId: 'root', item: makeItem('x') }]);
+            expect(builder.menu.length).toBe(lenBefore);
+        });
+    });
+});

package/utils/sessionStorage.test.d.ts

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

package/utils/sessionStorage.test.js

@@ -0,0 +1,81 @@
+/// <reference types="vitest" />
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { StorageKey } from './constants';
+import { getAxiosCache, getStored, removeStored, setAxiosCache, setStored } from './sessionStorage';
+// The sessionStorage module uses a debounced write (3 000 ms). Tests that need to verify
+// persistence to sessionStorage use fake timers and advance past the debounce delay.
+// afterEach flushes any pending changes so module-level state is clean for the next test.
+const DEBOUNCE_MS = 3100; // slightly past the 3 000 ms throttle
+const SESSION_PREFIX = 'howler.ui.cache';
+describe('sessionStorage utilities', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        // Flush pending debounced writes – this also resets the internal `changes` map.
+        vi.advanceTimersByTime(DEBOUNCE_MS);
+        vi.useRealTimers();
+        sessionStorage.clear();
+    });
+    // -------------------------------------------------------------------------
+    // getAxiosCache / setAxiosCache
+    // -------------------------------------------------------------------------
+    describe('getAxiosCache / setAxiosCache', () => {
+        it('returns an empty object when no cache has been stored', () => {
+            expect(getAxiosCache()).toEqual({});
+        });
+        it('stores and retrieves a cached entry after the debounce fires', () => {
+            setAxiosCache('etag-1', { data: 'value' });
+            vi.advanceTimersByTime(DEBOUNCE_MS);
+            expect(getAxiosCache()['etag-1']).toEqual({ data: 'value' });
+        });
+        it('accumulates multiple distinct cache entries', () => {
+            setAxiosCache('etag-a', { data: 'a' });
+            setAxiosCache('etag-b', { data: 'b' });
+            vi.advanceTimersByTime(DEBOUNCE_MS);
+            const cache = getAxiosCache();
+            expect(cache['etag-a']).toEqual({ data: 'a' });
+            expect(cache['etag-b']).toEqual({ data: 'b' });
+        });
+        it('overwrites an earlier entry for the same etag', () => {
+            setAxiosCache('etag-1', { data: 'old' });
+            setAxiosCache('etag-1', { data: 'new' });
+            vi.advanceTimersByTime(DEBOUNCE_MS);
+            expect(getAxiosCache()['etag-1']).toEqual({ data: 'new' });
+        });
+    });
+    // -------------------------------------------------------------------------
+    // setStored / getStored (object values)
+    // -------------------------------------------------------------------------
+    describe('setStored / getStored', () => {
+        it('makes an object value immediately readable via getStored (in-memory, before flush)', () => {
+            setStored(StorageKey.AXIOS_CACHE, { immediate: true });
+            // Timer has NOT advanced yet – data is in the in-memory `changes` map.
+            const result = getStored(StorageKey.AXIOS_CACHE);
+            expect(result.immediate).toBe(true);
+        });
+        it('persists an object value to sessionStorage after the debounce delay', () => {
+            const key = `${SESSION_PREFIX}.${StorageKey.AXIOS_CACHE}`;
+            setStored(StorageKey.AXIOS_CACHE, { persisted: true });
+            // Before flush: sessionStorage is still empty.
+            expect(sessionStorage.getItem(key)).toBeNull();
+            vi.advanceTimersByTime(DEBOUNCE_MS);
+            expect(JSON.parse(sessionStorage.getItem(key))).toEqual({ persisted: true });
+        });
+    });
+    // -------------------------------------------------------------------------
+    // removeStored
+    // -------------------------------------------------------------------------
+    describe('removeStored', () => {
+        it('removes a key from sessionStorage', () => {
+            setStored(StorageKey.AXIOS_CACHE, { val: 1 });
+            vi.advanceTimersByTime(DEBOUNCE_MS);
+            removeStored(StorageKey.AXIOS_CACHE);
+            const key = `${SESSION_PREFIX}.${StorageKey.AXIOS_CACHE}`;
+            expect(sessionStorage.getItem(key)).toBeNull();
+        });
+        it('does not throw when removing a key that was never set', () => {
+            expect(() => removeStored(StorageKey.AXIOS_CACHE)).not.toThrow();
+        });
+    });
+});

package/utils/socketUtils.d.ts

@@ -1,22 +1,8 @@
 import type { RecievedDataType } from '@cccsaurora/howler-ui/components/app/providers/SocketProvider';
-import type { CaseUpdate } from '@cccsaurora/howler-ui/models/socket/CaseUpdate';
 import type { HitUpdate } from '@cccsaurora/howler-ui/models/socket/HitUpdate';
-import type { ViewersUpdate } from '@cccsaurora/howler-ui/models/socket/ViewersUpdate';
 /**
  * Checks to see if the data recieved from the socket is a hit update
  * @param data The data recieved from the socket
  * @returns whether the data is a hit update
  */
 export declare const isHitUpdate: (data: any) => data is RecievedDataType<HitUpdate>;
-/**
- * Checks to see if the data received from the socket is a case update
- * @param data The data received from the socket
- * @returns whether the data is a case update
- */
-export declare const isCaseUpdate: (data: any) => data is RecievedDataType<CaseUpdate>;
-/**
- * Checks to see if the data received from the socket is a viewers update
- * @param data The data received from the socket
- * @returns whether the data is a viewers update
- */
-export declare const isViewersUpdate: (data: any) => data is RecievedDataType<ViewersUpdate>;

package/utils/socketUtils.js

@@ -4,21 +4,5 @@
  * @returns whether the data is a hit update
  */
 export const isHitUpdate = (data) => {
-    return !!(data.version && data.hit);
-};
-/**
- * Checks to see if the data received from the socket is a case update
- * @param data The data received from the socket
- * @returns whether the data is a case update
- */
-export const isCaseUpdate = (data) => {
-    return !!(data.type === 'cases' && data.case);
-};
-/**
- * Checks to see if the data received from the socket is a viewers update
- * @param data The data received from the socket
- * @returns whether the data is a viewers update
- */
-export const isViewersUpdate = (data) => {
-    return !!(data.type === 'viewers_update' && data.viewers && data.id);
+    return data.version && data.hit;
 };

package/utils/socketUtils.test.js

@@ -1,59 +1,26 @@
+/// <reference types="vitest" />
 import { describe, expect, it } from 'vitest';
-import { isCaseUpdate, isHitUpdate, isViewersUpdate } from './socketUtils';
+import { isHitUpdate } from './socketUtils';
 describe('isHitUpdate', () => {
-    it('returns true when data has version and hit', () => {
-        const data = { version: '1', hit: { howler: { id: 'h1' } }, type: 'hits', error: false, message: '', status: 200 };
-        expect(isHitUpdate(data)).toBeTruthy();
+    it('returns truthy when data has both a truthy version and a hit', () => {
+        expect(isHitUpdate({ version: 1, hit: {} })).toBeTruthy();
     });
-    it('returns false when hit is missing', () => {
-        const data = { version: '1', type: 'hits', error: false, message: '', status: 200 };
-        expect(isHitUpdate(data)).toBeFalsy();
+    it('returns truthy when version is a non-empty string', () => {
+        expect(isHitUpdate({ version: 'v1', hit: { howler: {} } })).toBeTruthy();
     });
-    it('returns false when version is missing', () => {
-        const data = { hit: { howler: { id: 'h1' } }, type: 'hits', error: false, message: '', status: 200 };
-        expect(isHitUpdate(data)).toBeFalsy();
+    it('returns falsy when version is missing', () => {
+        expect(isHitUpdate({ hit: {} })).toBeFalsy();
     });
-});
-describe('isCaseUpdate', () => {
-    it('returns true when type is cases and case is present', () => {
-        const data = { type: 'cases', case: { case_id: 'c1' }, error: false, message: '', status: 200 };
-        expect(isCaseUpdate(data)).toBeTruthy();
-    });
-    it('returns false when type is not cases', () => {
-        const data = { type: 'hits', case: { case_id: 'c1' }, error: false, message: '', status: 200 };
-        expect(isCaseUpdate(data)).toBeFalsy();
-    });
-    it('returns false when case is missing', () => {
-        const data = { type: 'cases', error: false, message: '', status: 200 };
-        expect(isCaseUpdate(data)).toBeFalsy();
-    });
-    it('returns false when case is null', () => {
-        const data = { type: 'cases', case: null, error: false, message: '', status: 200 };
-        expect(isCaseUpdate(data)).toBeFalsy();
-    });
-});
-describe('isViewersUpdate', () => {
-    it('returns true when type is viewers_update with id and viewers', () => {
-        const data = {
-            type: 'viewers_update',
-            id: 'entity-1',
-            viewers: ['alice', 'bob'],
-            error: false,
-            message: '',
-            status: 200
-        };
-        expect(isViewersUpdate(data)).toBeTruthy();
+    it('returns falsy when hit is missing', () => {
+        expect(isHitUpdate({ version: 1 })).toBeFalsy();
     });
-    it('returns false when type is wrong', () => {
-        const data = { type: 'cases', id: 'entity-1', viewers: ['alice'], error: false, message: '', status: 200 };
-        expect(isViewersUpdate(data)).toBeFalsy();
+    it('returns falsy when both fields are missing', () => {
+        expect(isHitUpdate({})).toBeFalsy();
     });
-    it('returns false when viewers is missing', () => {
-        const data = { type: 'viewers_update', id: 'entity-1', error: false, message: '', status: 200 };
-        expect(isViewersUpdate(data)).toBeFalsy();
+    it('returns falsy when version is 0 (falsy)', () => {
+        expect(isHitUpdate({ version: 0, hit: {} })).toBeFalsy();
     });
-    it('returns false when id is missing', () => {
-        const data = { type: 'viewers_update', viewers: ['alice'], error: false, message: '', status: 200 };
-        expect(isViewersUpdate(data)).toBeFalsy();
+    it('returns falsy when hit is null (falsy)', () => {
+        expect(isHitUpdate({ version: 1, hit: null })).toBeFalsy();
     });
 });

package/utils/stringUtils.test.d.ts

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

package/utils/stringUtils.test.js

@@ -0,0 +1,159 @@
+/// <reference types="vitest" />
+import { describe, expect, it } from 'vitest';
+import { maxLenStr, nameToInitials, safeFieldValue, safeFieldValueURI, safeStringPropertyCompare, sanitizeLuceneQuery, sanitizeMultilineLucene, validateRegex } from './stringUtils';
+describe('nameToInitials', () => {
+    it('returns initials from a standard first-last name', () => {
+        expect(nameToInitials('John Doe')).toEqual(['J', 'D']);
+    });
+    it('returns a single initial when there is only one word', () => {
+        expect(nameToInitials('John')).toEqual(['J']);
+    });
+    it('uses only the first two words even when there are more', () => {
+        expect(nameToInitials('John Middle Doe')).toEqual(['J', 'M']);
+    });
+    it('reverses order when the name is in "last, first" comma format', () => {
+        // "Smith, John" → parts = ["Smith,", "John"] → reversed → ["John", "Smith,"] → initials ["J", "S"]
+        expect(nameToInitials('Smith, John')).toEqual(['J', 'S']);
+    });
+    it('returns uppercase initials regardless of input case', () => {
+        expect(nameToInitials('alice bob')).toEqual(['A', 'B']);
+    });
+});
+describe('maxLenStr', () => {
+    it('returns the string unchanged when shorter than the limit', () => {
+        expect(maxLenStr('hello', 10)).toBe('hello');
+    });
+    it('returns the string unchanged when length equals the limit', () => {
+        expect(maxLenStr('hello', 5)).toBe('hello');
+    });
+    it('truncates and appends "..." when string exceeds the limit', () => {
+        expect(maxLenStr('hello world', 8)).toBe('hello...');
+    });
+    it('handles an empty string', () => {
+        expect(maxLenStr('', 5)).toBe('');
+    });
+    it('truncation accounts for the three-character ellipsis', () => {
+        // len=6 → keeps first 3 chars then "..."
+        expect(maxLenStr('abcdefgh', 6)).toBe('abc...');
+    });
+});
+describe('safeFieldValue', () => {
+    it('wraps a plain string in double quotes', () => {
+        expect(safeFieldValue('test')).toBe('"test"');
+    });
+    it('escapes backslashes', () => {
+        expect(safeFieldValue('back\\slash')).toBe('"back\\\\slash"');
+    });
+    it('escapes embedded double quotes', () => {
+        expect(safeFieldValue('say "hello"')).toBe('"say \\"hello\\""');
+    });
+    it('converts a number to a quoted string', () => {
+        expect(safeFieldValue(42)).toBe('"42"');
+    });
+    it('converts a boolean to a quoted string', () => {
+        expect(safeFieldValue(true)).toBe('"true"');
+    });
+    it('escapes backslash before escaping quotes (order matters)', () => {
+        expect(safeFieldValue('\\"')).toBe('"\\\\\\"\"');
+    });
+});
+describe('safeFieldValueURI', () => {
+    it('URI-encodes the safe field value of a plain string', () => {
+        expect(safeFieldValueURI('hello')).toBe(encodeURIComponent('"hello"'));
+    });
+    it('URI-encodes special characters', () => {
+        expect(safeFieldValueURI('hello world')).toBe(encodeURIComponent('"hello world"'));
+    });
+    it('handles strings that already contain lucene special chars', () => {
+        const input = 'field:value';
+        expect(safeFieldValueURI(input)).toBe(encodeURIComponent(safeFieldValue(input)));
+    });
+});
+describe('sanitizeLuceneQuery', () => {
+    it('escapes colons', () => {
+        expect(sanitizeLuceneQuery('field:value')).toBe('field\\:value');
+    });
+    it('escapes forward slashes', () => {
+        expect(sanitizeLuceneQuery('path/to')).toBe('path\\/to');
+    });
+    it('escapes opening parenthesis', () => {
+        expect(sanitizeLuceneQuery('(term)')).toBe('\\(term\\)');
+    });
+    it('escapes square brackets', () => {
+        expect(sanitizeLuceneQuery('[a TO b]')).toBe('\\[a TO b\\]');
+    });
+    it('escapes curly braces', () => {
+        expect(sanitizeLuceneQuery('{a TO b}')).toBe('\\{a TO b\\}');
+    });
+    it('escapes carets', () => {
+        expect(sanitizeLuceneQuery('term^2')).toBe('term\\^2');
+    });
+    it('escapes double-ampersand (&&)', () => {
+        expect(sanitizeLuceneQuery('a && b')).toBe('a \\&& b');
+    });
+    it('escapes double-pipe (||)', () => {
+        expect(sanitizeLuceneQuery('a || b')).toBe('a \\|| b');
+    });
+    it('leaves a plain alphanumeric string unchanged', () => {
+        expect(sanitizeLuceneQuery('plainterm')).toBe('plainterm');
+    });
+});
+describe('safeStringPropertyCompare', () => {
+    const compare = safeStringPropertyCompare('name');
+    it('returns a negative number when a sorts before b', () => {
+        expect(compare({ name: 'Alice' }, { name: 'Bob' })).toBeLessThan(0);
+    });
+    it('returns a positive number when a sorts after b', () => {
+        expect(compare({ name: 'Bob' }, { name: 'Alice' })).toBeGreaterThan(0);
+    });
+    it('returns 0 for equal strings', () => {
+        expect(compare({ name: 'Alice' }, { name: 'Alice' })).toBe(0);
+    });
+    it('returns 1 when only a has the property', () => {
+        expect(compare({ name: 'Alice' }, {})).toBe(1);
+    });
+    it('returns 0 when only b has the property', () => {
+        expect(compare({}, { name: 'Bob' })).toBe(0);
+    });
+    it('returns 0 when neither object has the property', () => {
+        expect(compare({}, {})).toBe(0);
+    });
+    it('supports nested property paths', () => {
+        const nestedCompare = safeStringPropertyCompare('user.name');
+        expect(nestedCompare({ user: { name: 'Alice' } }, { user: { name: 'Bob' } })).toBeLessThan(0);
+    });
+});
+describe('sanitizeMultilineLucene', () => {
+    it('removes a trailing inline comment', () => {
+        expect(sanitizeMultilineLucene('query # comment')).toBe('query ');
+    });
+    it('removes a full-line comment', () => {
+        expect(sanitizeMultilineLucene('# full line\nquery')).toBe('\nquery');
+    });
+    it('collapses two or more consecutive newlines into one', () => {
+        expect(sanitizeMultilineLucene('a\n\n\nb')).toBe('a\nb');
+    });
+    it('collapses exactly two consecutive newlines', () => {
+        expect(sanitizeMultilineLucene('a\n\nb')).toBe('a\nb');
+    });
+    it('leaves a clean single-line query unchanged', () => {
+        expect(sanitizeMultilineLucene('howler.status:open')).toBe('howler.status:open');
+    });
+});
+describe('validateRegex', () => {
+    it('returns true for a valid regex pattern', () => {
+        expect(validateRegex('[a-z]+')).toBe(true);
+    });
+    it('returns true for an empty string (valid zero-length pattern)', () => {
+        expect(validateRegex('')).toBe(true);
+    });
+    it('returns false for an invalid regex pattern', () => {
+        expect(validateRegex('[unclosed')).toBe(false);
+    });
+    it('returns true for a complex but valid regex', () => {
+        expect(validateRegex('^(\\d{4})-(\\d{2})-(\\d{2})$')).toBe(true);
+    });
+    it('returns true for a pattern with quantifiers', () => {
+        expect(validateRegex('a{2,5}')).toBe(true);
+    });
+});

package/utils/utils.test.d.ts

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