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

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.js

@@ -7,8 +7,5 @@ export const buildViewUrl = (view) => {
     if (view.sort) {
         params.set('sort', view.sort);
     }
-    if (view.indexes && view.indexes.length > 0) {
-        view.indexes.forEach(index => params.append('index', index));
-    }
     return `/search?${params.toString()}`;
 };

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

package/api/search/case.d.ts

@@ -1,4 +0,0 @@
-import type { HowlerSearchRequest, HowlerSearchResponse } from '@cccsaurora/howler-ui/api/search';
-import type { Case } from '@cccsaurora/howler-ui/models/entities/generated/Case';
-export declare const uri: () => string;
-export declare const post: (request?: HowlerSearchRequest) => Promise<HowlerSearchResponse<Case>>;

package/api/search/case.js

@@ -1,8 +0,0 @@
-import { hpost, joinUri } from '@cccsaurora/howler-ui/api';
-import { uri as parentUri } from '@cccsaurora/howler-ui/api/search';
-export const uri = () => {
-    return joinUri(parentUri(), 'case');
-};
-export const post = (request) => {
-    return hpost(uri(), { ...(request || {}), query: request?.query || 'case_id:*' });
-};

package/api/socket/index.d.ts

@@ -1,3 +0,0 @@
-import * as viewers from '@cccsaurora/howler-ui/api/socket/viewers';
-export declare const uri: () => string;
-export { viewers };

package/api/socket/index.js

@@ -1,6 +0,0 @@
-import { joinAllUri } from '@cccsaurora/howler-ui/api';
-import * as viewers from '@cccsaurora/howler-ui/api/socket/viewers';
-export const uri = () => {
-    return joinAllUri('/socket', 'v1');
-};
-export { viewers };

package/api/socket/viewers.d.ts

@@ -1,2 +0,0 @@
-export declare const uri: (entityId?: string) => string;
-export declare const get: (entityId: string) => Promise<string[]>;

package/api/socket/viewers.js

@@ -1,8 +0,0 @@
-import { hget, joinAllUri } from '@cccsaurora/howler-ui/api';
-import { uri as parentUri } from '@cccsaurora/howler-ui/api/socket';
-export const uri = (entityId) => {
-    return entityId ? joinAllUri(parentUri(), 'viewers', entityId) : joinAllUri(parentUri(), 'viewers');
-};
-export const get = async (entityId) => {
-    return hget(uri(entityId));
-};

package/api/socket/viewers.test.js

@@ -1,44 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-// ---------------------------------------------------------------------------
-// Hoisted mocks
-// ---------------------------------------------------------------------------
-const mockHget = vi.hoisted(() => vi.fn());
-vi.mock('api', async () => {
-    const urlJoin = (await import('url-join')).default;
-    return {
-        hget: mockHget,
-        joinAllUri: (...parts) => urlJoin(...parts)
-    };
-});
-// ---------------------------------------------------------------------------
-// Import after mocks
-// ---------------------------------------------------------------------------
-// eslint-disable-next-line
-import { get } from './viewers';
-// ---------------------------------------------------------------------------
-// Setup
-// ---------------------------------------------------------------------------
-beforeEach(() => {
-    mockHget.mockReset();
-});
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-describe('viewers API', () => {
-    describe('get', () => {
-        it('calls hget with the correct URI', async () => {
-            mockHget.mockResolvedValue(['alice', 'bob']);
-            await get('entity-1');
-            expect(mockHget).toHaveBeenCalledWith('/socket/v1/viewers/entity-1');
-        });
-        it('returns the result from hget', async () => {
-            mockHget.mockResolvedValue(['alice', 'bob']);
-            const result = await get('entity-1');
-            expect(result).toEqual(['alice', 'bob']);
-        });
-        it('propagates errors from hget', async () => {
-            mockHget.mockRejectedValue(new Error('not found'));
-            await expect(get('entity-1')).rejects.toThrow('not found');
-        });
-    });
-});

package/api/v2/case/index.d.ts

@@ -1,9 +0,0 @@
-import * as items from '@cccsaurora/howler-ui/api/v2/case/items';
-import * as rules from '@cccsaurora/howler-ui/api/v2/case/rules';
-import type { Case } from '@cccsaurora/howler-ui/models/entities/generated/Case';
-export declare const uri: (id?: string) => string;
-export declare const get: (id: string) => Promise<Case>;
-export declare const post: (newData: Partial<Case>) => Promise<Case>;
-export declare const put: (id: string, _case: Partial<Case>) => Promise<Case>;
-export declare const del: (id: string) => Promise<void>;
-export { items, rules };

package/api/v2/case/index.js

@@ -1,21 +0,0 @@
-// eslint-disable-next-line import/no-cycle
-import { hdelete, hget, hpost, hput, joinAllUri, joinUri } from '@cccsaurora/howler-ui/api';
-import { uri as parentUri } from '@cccsaurora/howler-ui/api/v2';
-import * as items from '@cccsaurora/howler-ui/api/v2/case/items';
-import * as rules from '@cccsaurora/howler-ui/api/v2/case/rules';
-export const uri = (id) => {
-    return id ? joinAllUri(parentUri(), 'case', id) : joinUri(parentUri(), 'case');
-};
-export const get = (id) => {
-    return hget(uri(id));
-};
-export const post = (newData) => {
-    return hpost(uri(), newData);
-};
-export const put = (id, _case) => {
-    return hput(uri(id), _case);
-};
-export const del = (id) => {
-    return hdelete(uri(id));
-};
-export { items, rules };

package/api/v2/case/items.d.ts

@@ -1,6 +0,0 @@
-import type { Case } from '@cccsaurora/howler-ui/models/entities/generated/Case';
-import type { Item } from '@cccsaurora/howler-ui/models/entities/generated/Item';
-export declare const uri: (id: string) => string;
-export declare const post: (id: string, newData: Item) => Promise<Case>;
-export declare const del: (id: string, values: string | string[]) => Promise<Case>;
-export declare const put: (id: string, value: string, newPath: string) => Promise<Case>;

package/api/v2/case/items.js

@@ -1,18 +0,0 @@
-// eslint-disable-next-line import/no-cycle
-import { hdelete, hpost, hput, joinUri } from '@cccsaurora/howler-ui/api';
-import { uri as parentUri } from '@cccsaurora/howler-ui/api/v2/case';
-export const uri = (id) => {
-    return joinUri(parentUri(id), 'items');
-};
-export const post = (id, newData) => {
-    return hpost(uri(id), newData);
-};
-export const del = (id, values) => {
-    if (!Array.isArray(values)) {
-        values = [values];
-    }
-    return hdelete(uri(id), { values });
-};
-export const put = (id, value, newPath) => {
-    return hput(uri(id), { value, new_path: newPath });
-};

package/api/v2/case/rules.d.ts

@@ -1,6 +0,0 @@
-import type { Case } from '@cccsaurora/howler-ui/models/entities/generated/Case';
-import type { Rule } from '@cccsaurora/howler-ui/models/entities/generated/Rule';
-export declare const uri: (caseId: string, ruleId?: string) => string;
-export declare const post: (caseId: string, ruleData: Partial<Rule>) => Promise<Case>;
-export declare const del: (caseId: string, ruleId: string) => Promise<Case>;
-export declare const put: (caseId: string, ruleId: string, data: Partial<Rule>) => Promise<Case>;

package/api/v2/case/rules.js

@@ -1,18 +0,0 @@
-// eslint-disable-next-line import/no-cycle
-import { hdelete, hpost, hput, joinAllUri } from '@cccsaurora/howler-ui/api';
-import { uri as parentUri } from '@cccsaurora/howler-ui/api/v2/case';
-export const uri = (caseId, ruleId) => {
-    if (ruleId) {
-        return joinAllUri(parentUri(caseId), 'rules', ruleId);
-    }
-    return joinAllUri(parentUri(caseId), 'rules');
-};
-export const post = (caseId, ruleData) => {
-    return hpost(uri(caseId), ruleData);
-};
-export const del = (caseId, ruleId) => {
-    return hdelete(uri(caseId, ruleId));
-};
-export const put = (caseId, ruleId, data) => {
-    return hput(uri(caseId, ruleId), data);
-};

package/api/v2/index.d.ts

@@ -1,4 +0,0 @@
-import * as case_ from '@cccsaurora/howler-ui/api/v2/case';
-import * as search from '@cccsaurora/howler-ui/api/v2/search';
-export declare const uri: () => string;
-export { case_ as case, search };

package/api/v2/index.js

@@ -1,6 +0,0 @@
-import * as case_ from '@cccsaurora/howler-ui/api/v2/case';
-import * as search from '@cccsaurora/howler-ui/api/v2/search';
-export const uri = () => {
-    return '/api/v2';
-};
-export { case_ as case, search };

package/api/v2/search/facet.d.ts

@@ -1,3 +0,0 @@
-import type { HowlerFacetSearchRequest, HowlerFacetSearchResponse } from '@cccsaurora/howler-ui/api/search/facet';
-export declare const uri: (indexes: string[]) => string;
-export declare const post: (indexes: string | string[], request?: HowlerFacetSearchRequest) => Promise<HowlerFacetSearchResponse>;

package/api/v2/search/facet.js

@@ -1,12 +0,0 @@
-// eslint-disable-next-line import/no-cycle
-import { hpost, joinAllUri } from '@cccsaurora/howler-ui/api';
-import { uri as parentUri } from '@cccsaurora/howler-ui/api/v2';
-export const uri = (indexes) => {
-    return joinAllUri(parentUri(), 'search', 'facet', indexes.join(','));
-};
-export const post = (indexes, request) => {
-    if (typeof indexes === 'string') {
-        indexes = indexes.split(',');
-    }
-    return hpost(uri(indexes), { ...(request || {}), query: request?.query || 'howler.id:*' });
-};

package/api/v2/search/index.d.ts

@@ -1,5 +0,0 @@
-import type { HowlerSearchRequest, HowlerSearchResponse } from '@cccsaurora/howler-ui/api/search';
-import * as facet from './facet';
-export declare const uri: (indexes: string[]) => string;
-export declare const post: <T = any>(indexes: string | string[], request?: HowlerSearchRequest) => Promise<HowlerSearchResponse<T>>;
-export { facet };

package/api/v2/search/index.js

@@ -1,24 +0,0 @@
-// eslint-disable-next-line import/no-cycle
-import { hpost, joinAllUri } from '@cccsaurora/howler-ui/api';
-import { uri as parentUri } from '@cccsaurora/howler-ui/api/v2';
-import { identity, isNil } from 'lodash-es';
-import * as facet from './facet';
-export const uri = (indexes) => {
-    return joinAllUri(parentUri(), 'search', indexes.join(','));
-};
-export const post = (indexes, request) => {
-    if (isNil(indexes)) {
-        throw new Error('Indexes cannot be null or undefined.');
-    }
-    if (typeof indexes === 'string') {
-        indexes = indexes.split(',').filter(identity);
-    }
-    if (indexes.some(index => !['hit', 'observable', 'case'].includes(index))) {
-        throw new Error('Only hit, case, and observable indexes should be used currently.');
-    }
-    if (indexes.length < 1) {
-        throw new Error('indexes must have length of at least 1.');
-    }
-    return hpost(uri(indexes), { ...(request || {}), query: request?.query || 'howler.id:*' });
-};
-export { facet };