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

package/utils/Throttler.test.js

@@ -0,0 +1,135 @@
+/// <reference types="vitest" />
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import Throttler from './Throttler';
+describe('Throttler', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    // -------------------------------------------------------------------------
+    // throttle
+    // -------------------------------------------------------------------------
+    describe('throttle', () => {
+        it('calls fn immediately on the first invocation', () => {
+            const fn = vi.fn();
+            const t = new Throttler(100);
+            t.throttle(fn);
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('suppresses subsequent calls within the throttle window', () => {
+            const fn = vi.fn();
+            const t = new Throttler(100);
+            t.throttle(fn);
+            t.throttle(fn);
+            t.throttle(fn);
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('allows another call after the throttle interval expires', () => {
+            const fn = vi.fn();
+            const t = new Throttler(100);
+            t.throttle(fn);
+            vi.advanceTimersByTime(150);
+            t.throttle(fn);
+            expect(fn).toHaveBeenCalledTimes(2);
+        });
+        it('does not fire a second call if the interval has not yet elapsed', () => {
+            const fn = vi.fn();
+            const t = new Throttler(200);
+            t.throttle(fn);
+            vi.advanceTimersByTime(100);
+            t.throttle(fn);
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // debounce
+    // -------------------------------------------------------------------------
+    describe('debounce', () => {
+        it('does not call fn immediately', () => {
+            const fn = vi.fn();
+            const t = new Throttler(100);
+            t.debounce(fn);
+            expect(fn).not.toHaveBeenCalled();
+        });
+        it('calls fn after the delay elapses', () => {
+            const fn = vi.fn();
+            const t = new Throttler(100);
+            t.debounce(fn);
+            vi.advanceTimersByTime(100);
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('resets the delay when called again before it fires', () => {
+            const fn = vi.fn();
+            const t = new Throttler(100);
+            t.debounce(fn);
+            vi.advanceTimersByTime(80);
+            t.debounce(fn);
+            vi.advanceTimersByTime(80);
+            expect(fn).not.toHaveBeenCalled();
+            vi.advanceTimersByTime(30);
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('calls fn only once after many rapid invocations', () => {
+            const fn = vi.fn();
+            const t = new Throttler(100);
+            for (let i = 0; i < 10; i++) {
+                t.debounce(fn);
+            }
+            vi.advanceTimersByTime(200);
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('fires a second call correctly after the first has resolved', () => {
+            const fn = vi.fn();
+            const t = new Throttler(100);
+            t.debounce(fn);
+            vi.advanceTimersByTime(150);
+            t.debounce(fn);
+            vi.advanceTimersByTime(150);
+            expect(fn).toHaveBeenCalledTimes(2);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // delayAsync
+    // -------------------------------------------------------------------------
+    describe('delayAsync', () => {
+        it('does not invoke fn before the delay', async () => {
+            const fn = vi.fn().mockResolvedValue('x');
+            const t = new Throttler(100);
+            t.delayAsync(fn);
+            expect(fn).not.toHaveBeenCalled();
+        });
+        it('resolves with the return value of fn', async () => {
+            const fn = vi.fn().mockResolvedValue('result');
+            const t = new Throttler(100);
+            const promise = t.delayAsync(fn);
+            vi.advanceTimersByTime(100);
+            await expect(promise).resolves.toBe('result');
+        });
+        it('passes variadic arguments through to fn', async () => {
+            const fn = vi.fn().mockImplementation(async (a, b) => a + b);
+            const t = new Throttler(100);
+            const promise = t.delayAsync(fn, 3, 4);
+            vi.advanceTimersByTime(100);
+            await expect(promise).resolves.toBe(7);
+        });
+        it('rejects when fn throws', async () => {
+            const fn = vi.fn().mockRejectedValue(new Error('boom'));
+            const t = new Throttler(100);
+            const promise = t.delayAsync(fn);
+            vi.advanceTimersByTime(100);
+            await expect(promise).rejects.toThrow('boom');
+        });
+        it('cancels the previous pending call when invoked again', async () => {
+            const fn = vi.fn().mockResolvedValue(42);
+            const t = new Throttler(100);
+            t.delayAsync(fn);
+            vi.advanceTimersByTime(50);
+            const second = t.delayAsync(fn);
+            vi.advanceTimersByTime(100);
+            await expect(second).resolves.toBe(42);
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+    });
+});

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/constants.d.ts

@@ -49,6 +49,7 @@ export declare enum StorageKey {
     COMPACT_JSON = "compact_json_view",
     FLATTEN_JSON = "flatten_json_view",
     FORCE_DRAWER = "force_drawer",
+    SHOW_HIT_SUMMARY_GRAPH = "show_hit_summary_graph",
     LAST_VIEW = "last_view",
     ONLY_RULES = "only_rules",
     PAGE_COUNT = "page_count",

package/utils/constants.js

@@ -54,6 +54,7 @@ export var StorageKey;
     StorageKey["COMPACT_JSON"] = "compact_json_view";
     StorageKey["FLATTEN_JSON"] = "flatten_json_view";
     StorageKey["FORCE_DRAWER"] = "force_drawer";
+    StorageKey["SHOW_HIT_SUMMARY_GRAPH"] = "show_hit_summary_graph";
     StorageKey["LAST_VIEW"] = "last_view";
     StorageKey["ONLY_RULES"] = "only_rules";
     StorageKey["PAGE_COUNT"] = "page_count";

package/utils/hitFunctions.test.d.ts

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

package/utils/hitFunctions.test.js

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest';
+import { getUserList } from './hitFunctions';
+const makeHit = (howlerOverrides = {}) => ({
+    howler: {
+        log: [],
+        comment: [],
+        ...howlerOverrides
+    }
+});
+describe('getUserList', () => {
+    it('returns an empty Set when the hit is null', () => {
+        expect(getUserList(null)).toEqual(new Set());
+    });
+    it('returns an empty Set when the hit is undefined', () => {
+        expect(getUserList(undefined)).toEqual(new Set());
+    });
+    it('returns an empty Set when both log and comment are empty', () => {
+        expect(getUserList(makeHit())).toEqual(new Set());
+    });
+    it('collects users from the log array', () => {
+        const hit = makeHit({ log: [{ user: 'alice' }, { user: 'bob' }] });
+        expect(getUserList(hit)).toEqual(new Set(['alice', 'bob']));
+    });
+    it('collects users from the comment array', () => {
+        const hit = makeHit({ comment: [{ user: 'carol' }] });
+        expect(getUserList(hit)).toEqual(new Set(['carol']));
+    });
+    it('collects users from both log and comment', () => {
+        const hit = makeHit({
+            log: [{ user: 'alice' }],
+            comment: [{ user: 'bob' }]
+        });
+        expect(getUserList(hit)).toEqual(new Set(['alice', 'bob']));
+    });
+    it('deduplicates users that appear in both arrays', () => {
+        const hit = makeHit({
+            log: [{ user: 'alice' }],
+            comment: [{ user: 'alice' }]
+        });
+        const result = getUserList(hit);
+        expect(result).toEqual(new Set(['alice']));
+        expect(result.size).toBe(1);
+    });
+    it('deduplicates users that appear multiple times in the same array', () => {
+        const hit = makeHit({ log: [{ user: 'alice' }, { user: 'alice' }] });
+        expect(getUserList(hit).size).toBe(1);
+    });
+    it('handles a hit with no howler field gracefully', () => {
+        const hit = {};
+        expect(getUserList(hit)).toEqual(new Set());
+    });
+});

package/utils/localStorage.test.d.ts

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

package/utils/localStorage.test.js

@@ -0,0 +1,96 @@
+/// <reference types="vitest" />
+import { afterEach, describe, expect, it } from 'vitest';
+import { StorageKey } from './constants';
+import { getStored, removeStored, saveLoginCredential, setStored } from './localStorage';
+const PREFIX = 'howler.ui';
+describe('localStorage utilities', () => {
+    afterEach(() => {
+        localStorage.clear();
+    });
+    // -------------------------------------------------------------------------
+    // setStored / getStored
+    // -------------------------------------------------------------------------
+    describe('setStored / getStored', () => {
+        it('stores and retrieves a string value', () => {
+            setStored(StorageKey.USERNAME, 'alice');
+            expect(getStored(StorageKey.USERNAME)).toBe('alice');
+        });
+        it('stores and retrieves an object value', () => {
+            const value = { token: 'abc', expires: 123 };
+            setStored(StorageKey.APP_TOKEN, value);
+            expect(getStored(StorageKey.APP_TOKEN)).toEqual(value);
+        });
+        it('uses the prefixed key in the underlying localStorage', () => {
+            setStored(StorageKey.USERNAME, 'bob');
+            expect(localStorage.getItem(`${PREFIX}.${StorageKey.USERNAME}`)).toBe(JSON.stringify('bob'));
+        });
+        it('returns null for a key that has not been set', () => {
+            expect(getStored(StorageKey.USERNAME)).toBeNull();
+        });
+        it('overwrites an existing value', () => {
+            setStored(StorageKey.USERNAME, 'alice');
+            setStored(StorageKey.USERNAME, 'bob');
+            expect(getStored(StorageKey.USERNAME)).toBe('bob');
+        });
+        it('stores a number value', () => {
+            setStored(StorageKey.PAGE_COUNT, 25);
+            expect(getStored(StorageKey.PAGE_COUNT)).toBe(25);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // removeStored
+    // -------------------------------------------------------------------------
+    describe('removeStored', () => {
+        it('removes an existing key so it returns null on subsequent reads', () => {
+            setStored(StorageKey.USERNAME, 'alice');
+            removeStored(StorageKey.USERNAME);
+            expect(getStored(StorageKey.USERNAME)).toBeNull();
+        });
+        it('does not throw when removing a key that was never stored', () => {
+            expect(() => removeStored(StorageKey.USERNAME)).not.toThrow();
+        });
+        it('removes only the targeted key and leaves others intact', () => {
+            setStored(StorageKey.USERNAME, 'alice');
+            setStored(StorageKey.PROVIDER, 'howler');
+            removeStored(StorageKey.USERNAME);
+            expect(getStored(StorageKey.USERNAME)).toBeNull();
+            expect(getStored(StorageKey.PROVIDER)).toBe('howler');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // saveLoginCredential
+    // -------------------------------------------------------------------------
+    describe('saveLoginCredential', () => {
+        it('returns true and stores app_token when app_token is present', () => {
+            const result = saveLoginCredential({ app_token: 'tok123' });
+            expect(result).toBe(true);
+            expect(getStored(StorageKey.APP_TOKEN)).toBe('tok123');
+        });
+        it('also stores refresh_token and provider when they are present', () => {
+            saveLoginCredential({ app_token: 'tok', refresh_token: 'ref', provider: 'howler' });
+            expect(getStored(StorageKey.REFRESH_TOKEN)).toBe('ref');
+            expect(getStored(StorageKey.PROVIDER)).toBe('howler');
+        });
+        it('does not store refresh_token when it is absent', () => {
+            saveLoginCredential({ app_token: 'tok' });
+            expect(getStored(StorageKey.REFRESH_TOKEN)).toBeNull();
+        });
+        it('returns false and clears stored tokens when app_token is absent', () => {
+            setStored(StorageKey.APP_TOKEN, 'old-token');
+            setStored(StorageKey.REFRESH_TOKEN, 'old-refresh');
+            const result = saveLoginCredential({});
+            expect(result).toBe(false);
+            expect(getStored(StorageKey.APP_TOKEN)).toBeNull();
+            expect(getStored(StorageKey.REFRESH_TOKEN)).toBeNull();
+        });
+        it('clears APP_TOKEN, REFRESH_TOKEN, and PROVIDER on empty credential', () => {
+            setStored(StorageKey.APP_TOKEN, 't');
+            setStored(StorageKey.REFRESH_TOKEN, 'r');
+            setStored(StorageKey.PROVIDER, 'p');
+            saveLoginCredential({});
+            expect(getStored(StorageKey.APP_TOKEN)).toBeNull();
+            expect(getStored(StorageKey.REFRESH_TOKEN)).toBeNull();
+            expect(getStored(StorageKey.PROVIDER)).toBeNull();
+        });
+    });
+});

package/utils/menuUtils.js

@@ -1,5 +1,5 @@
-import { MainMenuInsertOperation } from '../plugins/store';
 import { isNil } from 'lodash-es';
+import { MainMenuInsertOperation } from '../plugins/store';
 class AppMenuBuilder {
     items;
     indexMap;

package/utils/menuUtils.test.d.ts

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

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