@cccsaurora/howler-ui 2.19.0-dev.938 → 2.19.0-dev.950

package/package.json

@@ -96,7 +96,7 @@
     "internal-slot": "1.0.7"
   },
   "type": "module",
-  "version": "2.19.0-dev.938",
+  "version": "2.19.0-dev.950",
   "exports": {
     "./i18n": "./i18n.js",
     "./index.css": "./index.css",

package/setupTests.js

@@ -2,7 +2,12 @@
 import * as matchers from '@testing-library/jest-dom/matchers';
 import '@testing-library/jest-dom/vitest';
 import { configure } from '@testing-library/react';
+import dayjs from 'dayjs';
+import relativeTime from 'dayjs/plugin/relativeTime';
+import utc from 'dayjs/plugin/utc';
 import { server } from '@cccsaurora/howler-ui/tests/server';
+dayjs.extend(utc);
+dayjs.extend(relativeTime);
 globalThis.IS_REACT_ACT_ENVIRONMENT = true;
 // Extend vitest with the dom matchers from jest-dom.
 expect.extend(matchers);

package/utils/actionUtils.test.d.ts

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

package/utils/actionUtils.test.js

@@ -0,0 +1,140 @@
+import { describe, expect, it } from 'vitest';
+import { checkArgsAreFilled, getArgsByContext, getOptionsByContext, operationReady } from './actionUtils';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const makeStep = (args, options = {}) => ({
+    args,
+    options,
+    validation: {}
+});
+const makeAction = (steps) => ({
+    id: 'test-action',
+    title: 'Test Action',
+    i18nKey: 'test.action',
+    description: { short: '', long: '' },
+    roles: [],
+    steps,
+    triggers: []
+});
+// ---------------------------------------------------------------------------
+// checkArgsAreFilled
+// ---------------------------------------------------------------------------
+describe('checkArgsAreFilled', () => {
+    it('returns false when values is empty/falsy', () => {
+        const step = makeStep({ status: [] });
+        expect(checkArgsAreFilled(step, '')).toBe(false);
+    });
+    it('returns true when all required args are present and truthy', () => {
+        const step = makeStep({ status: [] });
+        expect(checkArgsAreFilled(step, JSON.stringify({ status: 'open' }))).toBe(true);
+    });
+    it('returns false when a required arg is missing from values', () => {
+        const step = makeStep({ status: [], assignment: [] });
+        expect(checkArgsAreFilled(step, JSON.stringify({ status: 'open' }))).toBe(false);
+    });
+    it('returns false when a required arg is present but falsy (empty string)', () => {
+        const step = makeStep({ status: [] });
+        expect(checkArgsAreFilled(step, JSON.stringify({ status: '' }))).toBe(false);
+    });
+    it('returns true when there are no required args', () => {
+        const step = makeStep({});
+        expect(checkArgsAreFilled(step, JSON.stringify({}))).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// getOptionsByContext
+// ---------------------------------------------------------------------------
+describe('getOptionsByContext', () => {
+    it('returns an empty array when the arg is not in options', () => {
+        const options = {};
+        expect(getOptionsByContext(options, 'status', '{}')).toEqual([]);
+    });
+    it('returns the full list when the arg maps to a plain array', () => {
+        const options = { status: ['open', 'in-progress', 'resolved'] };
+        expect(getOptionsByContext(options, 'status', '{}')).toEqual(['open', 'in-progress', 'resolved']);
+    });
+    it('returns options matching the current context when arg has conditional options', () => {
+        const options = {
+            assessment: {
+                'status:open': ['false_positive', 'legitimate'],
+                'status:resolved': ['correct']
+            }
+        };
+        const context = JSON.stringify({ status: 'open' });
+        expect(getOptionsByContext(options, 'assessment', context)).toEqual(['false_positive', 'legitimate']);
+    });
+    it('returns an empty array when context does not match any conditional key', () => {
+        const options = {
+            assessment: {
+                'status:open': ['false_positive']
+            }
+        };
+        const context = JSON.stringify({ status: 'resolved' });
+        expect(getOptionsByContext(options, 'assessment', context)).toEqual([]);
+    });
+});
+// ---------------------------------------------------------------------------
+// getArgsByContext
+// ---------------------------------------------------------------------------
+describe('getArgsByContext', () => {
+    it('always returns an arg with an empty conditions array', () => {
+        const args = { status: [] };
+        expect(getArgsByContext(args, '{}')).toContain('status');
+    });
+    it('includes an arg whose condition matches the current context', () => {
+        const args = { assessment: ['status:open'] };
+        const values = JSON.stringify({ status: 'open' });
+        expect(getArgsByContext(args, values)).toContain('assessment');
+    });
+    it('excludes an arg whose condition does not match the current context', () => {
+        const args = { assessment: ['status:open'] };
+        const values = JSON.stringify({ status: 'resolved' });
+        expect(getArgsByContext(args, values)).not.toContain('assessment');
+    });
+    it('includes an arg when any one of multiple conditions matches (OR logic)', () => {
+        const args = { rationale: ['status:open', 'status:in-progress'] };
+        const values = JSON.stringify({ status: 'in-progress' });
+        expect(getArgsByContext(args, values)).toContain('rationale');
+    });
+    it('returns an empty array when no args match', () => {
+        const args = { assessment: ['status:open'] };
+        const values = JSON.stringify({ status: 'resolved' });
+        expect(getArgsByContext(args, values)).toEqual([]);
+    });
+});
+// ---------------------------------------------------------------------------
+// operationReady
+// ---------------------------------------------------------------------------
+describe('operationReady', () => {
+    it('returns false when data is null/falsy', () => {
+        const action = makeAction([makeStep({ status: [] })]);
+        expect(operationReady(null, action)).toBe(false);
+    });
+    it('returns falsy when action is falsy', () => {
+        expect(operationReady(JSON.stringify({ status: 'open' }), null)).toBeFalsy();
+    });
+    it('returns true when all unconditional args are present', () => {
+        const action = makeAction([makeStep({ status: [] })]);
+        const data = JSON.stringify({ status: 'open' });
+        expect(operationReady(data, action)).toBe(true);
+    });
+    it('returns false when a required unconditional arg is missing', () => {
+        const action = makeAction([makeStep({ status: [], assessment: [] })]);
+        const data = JSON.stringify({ status: 'open' });
+        expect(operationReady(data, action)).toBe(false);
+    });
+    it('ignores conditional args that do not apply in the current context', () => {
+        // assessment only required when status=open; here status=resolved so assessment is not required
+        const action = makeAction([makeStep({ status: [], assessment: ['status:open'] })]);
+        const data = JSON.stringify({ status: 'resolved' });
+        expect(operationReady(data, action)).toBe(true);
+    });
+    it('merges args across multiple steps', () => {
+        const step1 = makeStep({ status: [] });
+        const step2 = makeStep({ assignment: [] });
+        const action = makeAction([step1, step2]);
+        const data = JSON.stringify({ status: 'open', assignment: 'alice' });
+        expect(operationReady(data, action)).toBe(true);
+    });
+});

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, twitterShort, tryParse } 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');
+    });
+});