@cccsaurora/howler-ui 2.18.0-dev.841 → 2.19.0-cases.1040

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/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 {};

package/utils/utils.test.js

@@ -0,0 +1,292 @@
+/// <reference types="vitest" />
+import { describe, expect, it } from 'vitest';
+import { bytesToSize, compareTimestamp, convertCustomDateRangeToLucene, convertDateToLucene, convertLuceneToDate, flattenDeep, formatDate, getTimeRange, hashCode, humanReadableNumber, removeEmpty, searchObject, sortByTimestamp, tryParse, twitterShort } from './utils';
+describe('bytesToSize', () => {
+    it('returns "0 B" for 0', () => {
+        expect(bytesToSize(0)).toBe('0 B');
+    });
+    it('returns "0 B" for null', () => {
+        expect(bytesToSize(null)).toBe('0 B');
+    });
+    it('formats bytes', () => {
+        expect(bytesToSize(512)).toBe('512 B');
+    });
+    it('formats kilobytes', () => {
+        expect(bytesToSize(1024)).toBe('1 KB');
+    });
+    it('formats megabytes', () => {
+        expect(bytesToSize(1024 * 1024)).toBe('1 MB');
+    });
+    it('formats gigabytes', () => {
+        expect(bytesToSize(1024 * 1024 * 1024)).toBe('1 GB');
+    });
+});
+describe('humanReadableNumber', () => {
+    it('returns "0 " for 0', () => {
+        expect(humanReadableNumber(0)).toBe('0 ');
+    });
+    it('returns "0 " for null', () => {
+        expect(humanReadableNumber(null)).toBe('0 ');
+    });
+    it('returns the number with a trailing space for values below 1000', () => {
+        expect(humanReadableNumber(500)).toBe('500 ');
+    });
+    it('formats thousands with "k"', () => {
+        expect(humanReadableNumber(1000)).toBe('1k ');
+    });
+    it('formats millions with "m"', () => {
+        expect(humanReadableNumber(1_000_000)).toBe('1m ');
+    });
+});
+describe('compareTimestamp', () => {
+    it('returns a negative number when a is earlier than b', () => {
+        expect(compareTimestamp('2021-01-01T00:00:00Z', '2021-01-02T00:00:00Z')).toBeLessThan(0);
+    });
+    it('returns a positive number when a is later than b', () => {
+        expect(compareTimestamp('2021-01-02T00:00:00Z', '2021-01-01T00:00:00Z')).toBeGreaterThan(0);
+    });
+    it('returns 0 for identical timestamps', () => {
+        expect(compareTimestamp('2021-01-01T00:00:00Z', '2021-01-01T00:00:00Z')).toBe(0);
+    });
+    it('returns a difference in seconds', () => {
+        // 86400 seconds = 1 day
+        expect(compareTimestamp('2021-01-02T00:00:00Z', '2021-01-01T00:00:00Z')).toBe(86400);
+    });
+});
+describe('hashCode', () => {
+    it('returns a number', () => {
+        expect(typeof hashCode('hello')).toBe('number');
+    });
+    it('returns the same value for the same input', () => {
+        expect(hashCode('hello')).toBe(hashCode('hello'));
+    });
+    it('returns different values for different inputs', () => {
+        expect(hashCode('hello')).not.toBe(hashCode('world'));
+    });
+    it('returns 0 for an empty string', () => {
+        expect(hashCode('')).toBe(0);
+    });
+});
+describe('sortByTimestamp', () => {
+    it('returns an empty array for an empty input', () => {
+        expect(sortByTimestamp([])).toEqual([]);
+    });
+    it('sorts items in descending timestamp order (most recent first)', () => {
+        const items = [
+            { timestamp: '2021-01-01T00:00:00Z' },
+            { timestamp: '2021-03-01T00:00:00Z' },
+            { timestamp: '2021-02-01T00:00:00Z' }
+        ];
+        const sorted = sortByTimestamp(items);
+        expect(sorted[0].timestamp).toBe('2021-03-01T00:00:00Z');
+        expect(sorted[2].timestamp).toBe('2021-01-01T00:00:00Z');
+    });
+    it('does not mutate the original array', () => {
+        const original = [{ timestamp: '2021-01-01T00:00:00Z' }, { timestamp: '2021-03-01T00:00:00Z' }];
+        const copy = [...original];
+        sortByTimestamp(original);
+        expect(original).toEqual(copy);
+    });
+    it('handles items with missing timestamps', () => {
+        const items = [{ timestamp: '2021-01-01T00:00:00Z' }, {}];
+        expect(() => sortByTimestamp(items)).not.toThrow();
+    });
+});
+describe('getTimeRange', () => {
+    it('returns [earliest, latest] from an array of timestamps', () => {
+        const timestamps = ['2021-03-01T00:00:00Z', '2021-01-01T00:00:00Z', '2021-02-01T00:00:00Z'];
+        const [start, end] = getTimeRange(timestamps);
+        expect(start).toBe('2021-01-01T00:00:00Z');
+        expect(end).toBe('2021-03-01T00:00:00Z');
+    });
+    it('returns the same value for both when given a single timestamp', () => {
+        const [start, end] = getTimeRange(['2021-01-01T00:00:00Z']);
+        expect(start).toBe(end);
+    });
+});
+describe('removeEmpty', () => {
+    it('removes null values from a flat object', () => {
+        expect(removeEmpty({ a: null, b: 'val' })).toEqual({ b: 'val' });
+    });
+    it('removes undefined values from a flat object', () => {
+        expect(removeEmpty({ a: undefined, b: 'val' })).toEqual({ b: 'val' });
+    });
+    it('recursively removes null values from nested objects', () => {
+        expect(removeEmpty({ nested: { a: null, b: 'val' } })).toEqual({ nested: { b: 'val' } });
+    });
+    it('handles an empty object', () => {
+        expect(removeEmpty({})).toEqual({});
+    });
+    it('handles null input gracefully', () => {
+        expect(removeEmpty(null)).toEqual({});
+    });
+    it('keeps arrays as-is', () => {
+        const result = removeEmpty({ arr: [1, 2, 3] });
+        expect(result.arr).toEqual([1, 2, 3]);
+    });
+});
+describe('searchObject', () => {
+    const obj = { name: 'Alice', role: 'admin', nested: { city: 'Ottawa' } };
+    it('returns the full object when query is empty', () => {
+        const result = searchObject(obj, '');
+        expect(result).toMatchObject(obj);
+    });
+    it('returns matching entries for a key match', () => {
+        const result = searchObject(obj, 'name');
+        expect(result.name).toBe('Alice');
+    });
+    it('returns matching entries for a value match', () => {
+        const result = searchObject(obj, 'Alice');
+        expect(result.name).toBe('Alice');
+    });
+    it('returns an empty object when nothing matches', () => {
+        const result = searchObject(obj, 'zzznomatch');
+        expect(result).toEqual({});
+    });
+    it('returns flat result when returnFlat=true', () => {
+        const result = searchObject(obj, 'city', true);
+        expect(result['nested.city']).toBe('Ottawa');
+    });
+    it('returns full flat object when query is empty and returnFlat=true', () => {
+        const result = searchObject({ a: 1 }, '', true);
+        expect(result.a).toBe(1);
+    });
+    it('handles an invalid regex gracefully by returning the full object', () => {
+        const result = searchObject(obj, '[invalid');
+        expect(result).toMatchObject(obj);
+    });
+});
+describe('convertDateToLucene', () => {
+    it('returns "[now-1d TO now]" for a 1-day range', () => {
+        expect(convertDateToLucene('date.range.1.day')).toBe('[now-1d TO now]');
+    });
+    it('returns "[now-1w TO now]" for a 1-week range', () => {
+        expect(convertDateToLucene('date.range.1.week')).toBe('[now-1w TO now]');
+    });
+    it('returns "[now-1M TO now]" for a 1-month range', () => {
+        expect(convertDateToLucene('date.range.1.month')).toBe('[now-1M TO now]');
+    });
+    it('returns "[now-1y TO now]" for a 1-year range', () => {
+        expect(convertDateToLucene('date.range.1.year')).toBe('[now-1y TO now]');
+    });
+    it('returns "*" for the "all" range', () => {
+        expect(convertDateToLucene('date.range.all')).toBe('*');
+    });
+    it('returns the default 1-day range when input does not start with "date.range."', () => {
+        expect(convertDateToLucene('something.else')).toBe('[now-1d TO now]');
+    });
+    it('uses the day unit as fallback for an unknown period type', () => {
+        expect(convertDateToLucene('date.range.3.unknown')).toBe('[now-3d TO now]');
+    });
+    it('handles multi-unit amounts', () => {
+        expect(convertDateToLucene('date.range.3.day')).toBe('[now-3d TO now]');
+    });
+});
+describe('convertCustomDateRangeToLucene', () => {
+    it('formats a custom date range', () => {
+        expect(convertCustomDateRangeToLucene('2021-01-01', '2021-12-31')).toBe('[2021-01-01 TO 2021-12-31]');
+    });
+    it('works with ISO datetime strings', () => {
+        expect(convertCustomDateRangeToLucene('2021-01-01T00:00:00Z', '2021-12-31T23:59:59Z')).toBe('[2021-01-01T00:00:00Z TO 2021-12-31T23:59:59Z]');
+    });
+});
+describe('convertLuceneToDate', () => {
+    it('converts a 1-day lucene range back to "date.range.1.day"', () => {
+        expect(convertLuceneToDate('event.created:[now-1d TO now]')).toBe('date.range.1.day');
+    });
+    it('converts a 1-week lucene range back to "date.range.1.week"', () => {
+        expect(convertLuceneToDate('event.created:[now-1w TO now]')).toBe('date.range.1.week');
+    });
+    it('converts a 1-month lucene range back to "date.range.1.month"', () => {
+        expect(convertLuceneToDate('event.created:[now-1M TO now]')).toBe('date.range.1.month');
+    });
+    it('returns the input unchanged when there is no colon (not a field query)', () => {
+        expect(convertLuceneToDate('*')).toBe('*');
+    });
+    it('falls back to "day" for an unrecognised unit suffix', () => {
+        expect(convertLuceneToDate('event.created:[now-5z TO now]')).toBe('date.range.5.day');
+    });
+});
+describe('tryParse', () => {
+    it('parses valid JSON and returns the value', () => {
+        expect(tryParse('{"a":1}')).toEqual({ a: 1 });
+    });
+    it('parses a JSON array', () => {
+        expect(tryParse('[1,2,3]')).toEqual([1, 2, 3]);
+    });
+    it('returns the raw string when JSON is invalid', () => {
+        expect(tryParse('not json')).toBe('not json');
+    });
+    it('parses a quoted JSON string', () => {
+        expect(tryParse('"hello"')).toBe('hello');
+    });
+    it('returns the raw string for partially-valid JSON', () => {
+        expect(tryParse('{invalid}')).toBe('{invalid}');
+    });
+});
+describe('flattenDeep', () => {
+    it('flattens a simple nested object', () => {
+        const result = flattenDeep({ a: { b: 1 } });
+        expect(result).toEqual({ 'a.b': 1 });
+    });
+    it('leaves a flat object unchanged', () => {
+        const result = flattenDeep({ a: 1, b: 2 });
+        expect(result).toEqual({ a: 1, b: 2 });
+    });
+    it('flattens arrays of objects by merging values under a common key', () => {
+        const result = flattenDeep({ items: [{ id: 'x' }, { id: 'y' }] });
+        expect(result['items.id']).toEqual(['x', 'y']);
+    });
+    it('keeps a primitive array as-is', () => {
+        const result = flattenDeep({ tags: ['a', 'b', 'c'] });
+        expect(result.tags).toEqual(['a', 'b', 'c']);
+    });
+    it('handles an empty object', () => {
+        expect(flattenDeep({})).toEqual({});
+    });
+});
+describe('formatDate', () => {
+    it('returns "?" for a falsy value', () => {
+        expect(formatDate(null)).toBe('?');
+    });
+    it('returns "?" for an empty string', () => {
+        expect(formatDate('')).toBe('?');
+    });
+    it('formats an ISO string as UTC in YYYY/MM/DD HH:mm:ss format', () => {
+        // 2021-06-15T12:30:45Z → UTC → "2021/06/15 12:30:45"
+        expect(formatDate('2021-06-15T12:30:45Z')).toBe('2021/06/15 12:30:45');
+    });
+    it('formats a Date object correctly', () => {
+        const date = new Date('2023-01-01T00:00:00Z');
+        expect(formatDate(date)).toBe('2023/01/01 00:00:00');
+    });
+    it('formats a unix timestamp (ms) correctly', () => {
+        // 1000ms = 1970-01-01T00:00:01Z
+        expect(formatDate(1000)).toBe('1970/01/01 00:00:01');
+    });
+    it('returns "?" for a numeric 0 (treated as falsy by the guard)', () => {
+        expect(formatDate(0)).toBe('?');
+    });
+});
+describe('twitterShort', () => {
+    it('returns "?" for a falsy value', () => {
+        expect(twitterShort(null)).toBe('?');
+    });
+    it('returns "?" for the literal string "?"', () => {
+        expect(twitterShort('?')).toBe('?');
+    });
+    it('returns a non-empty relative string for a recent date', () => {
+        const result = twitterShort(new Date().toISOString());
+        expect(result).toBeTruthy();
+        expect(typeof result).toBe('string');
+    });
+    it('returns "a few seconds ago" for a date just in the past', () => {
+        const recent = new Date(Date.now() - 2000).toISOString();
+        expect(twitterShort(recent)).toBe('a few seconds ago');
+    });
+    it('returns a sensible relative string for a date one year in the past', () => {
+        const oneYearAgo = new Date(Date.now() - 365 * 24 * 60 * 60 * 1000).toISOString();
+        const result = twitterShort(oneYearAgo);
+        expect(result).toMatch(/year/);
+    });
+});

package/utils/viewUtils.test.d.ts

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

package/utils/viewUtils.test.js

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest';
+import { buildViewUrl } from './viewUtils';
+const makeView = (overrides = {}) => ({
+    view_id: 'view-1',
+    title: 'Test View',
+    query: 'howler.status:open',
+    sort: 'event.created desc',
+    span: 'date.range.1.month',
+    type: 'personal',
+    owner: 'testuser',
+    ...overrides
+});
+describe('buildViewUrl', () => {
+    it('includes the view_id as the "view" query param', () => {
+        const url = buildViewUrl(makeView({ view_id: 'abc-123' }));
+        expect(url).toContain('view=abc-123');
+    });
+    it('starts with /search', () => {
+        const url = buildViewUrl(makeView());
+        expect(url.startsWith('/search?')).toBe(true);
+    });
+    it('includes the span param when provided', () => {
+        const url = buildViewUrl(makeView({ span: 'date.range.1.week' }));
+        expect(url).toContain('span=date.range.1.week');
+    });
+    it('omits the span param when span is undefined', () => {
+        const url = buildViewUrl(makeView({ span: undefined }));
+        expect(url).not.toContain('span=');
+    });
+    it('includes the sort param when provided', () => {
+        const url = buildViewUrl(makeView({ sort: 'event.created asc' }));
+        expect(url).toContain('sort=event.created+asc');
+    });
+    it('omits the sort param when sort is undefined', () => {
+        const url = buildViewUrl(makeView({ sort: undefined }));
+        expect(url).not.toContain('sort=');
+    });
+    it('builds a complete URL with all fields present', () => {
+        const url = buildViewUrl(makeView({ view_id: 'v1', span: 'date.range.1.day', sort: 'event.created desc' }));
+        const parsed = new URL(url, 'http://localhost');
+        expect(parsed.searchParams.get('view')).toBe('v1');
+        expect(parsed.searchParams.get('span')).toBe('date.range.1.day');
+        expect(parsed.searchParams.get('sort')).toBe('event.created desc');
+    });
+});

package/utils/xsrf.test.d.ts

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

package/utils/xsrf.test.js

@@ -0,0 +1,41 @@
+/// <reference types="vitest" />
+import { afterEach, describe, expect, it } from 'vitest';
+import getXSRFCookie from './xsrf';
+describe('getXSRFCookie', () => {
+    const originalDescriptor = Object.getOwnPropertyDescriptor(document, 'cookie');
+    const setCookie = (value) => {
+        Object.defineProperty(document, 'cookie', {
+            get: () => value,
+            configurable: true
+        });
+    };
+    afterEach(() => {
+        if (originalDescriptor) {
+            Object.defineProperty(document, 'cookie', originalDescriptor);
+        }
+    });
+    it('returns null when document.cookie is empty', () => {
+        setCookie('');
+        expect(getXSRFCookie()).toBeNull();
+    });
+    it('returns null when XSRF-TOKEN is not among the cookies', () => {
+        setCookie('session=abc; theme=dark');
+        expect(getXSRFCookie()).toBeNull();
+    });
+    it('returns the XSRF-TOKEN value when it is the only cookie', () => {
+        setCookie('XSRF-TOKEN=my-token');
+        expect(getXSRFCookie()).toBe('my-token');
+    });
+    it('returns the XSRF-TOKEN value when it appears among other cookies', () => {
+        setCookie('session=abc; XSRF-TOKEN=csrf-value; theme=dark');
+        expect(getXSRFCookie()).toBe('csrf-value');
+    });
+    it('returns the XSRF-TOKEN value when it appears first', () => {
+        setCookie('XSRF-TOKEN=first-token; session=abc');
+        expect(getXSRFCookie()).toBe('first-token');
+    });
+    it('returns the XSRF-TOKEN value when it appears last', () => {
+        setCookie('session=abc; XSRF-TOKEN=last-token');
+        expect(getXSRFCookie()).toBe('last-token');
+    });
+});