@fias/arche-sdk 2.30.0 → 2.32.0

package/dist/hooks.test.js

@@ -299,6 +299,15 @@ describe('SDK hooks', () => {
             chrome.openAssistant();
             expect(mockBridge.openAssistant).toHaveBeenCalled();
         });
+        it('carries where the person came from, null when nothing opened the arche', () => {
+            const { useFiasChrome } = require('./hooks');
+            expect(useFiasChrome().opener).toBeNull();
+            mockBridge.getChrome.mockReturnValue({
+                ...HOST_STATE,
+                opener: { kind: 'forge', name: 'My Arche' },
+            });
+            expect(useFiasChrome().opener).toEqual({ kind: 'forge', name: 'My Arche' });
+        });
         it('cleanup unsubscribes from chrome updates', () => {
             const unsubscribe = jest.fn();
             mockBridge.onChromeUpdate.mockReturnValue(unsubscribe);
@@ -854,6 +863,116 @@ describe('SDK hooks', () => {
             expect(mockBridge.request).toHaveBeenCalledWith(...entityOp(entity_ops_1.PLUGIN_WORKSPACES_ENTITY_ID, 'create', { forActingHolder: true }));
         });
     });
+    describe('useFiasWorkspaces() member targets (ADR-040 §4)', () => {
+        it('updateMember / removeMember send a ref target as { ref }, a string as { username }', async () => {
+            const { useFiasWorkspaces } = require('./hooks');
+            mockBridge.request.mockResolvedValue(output({ member: {} }));
+            await useFiasWorkspaces().updateMember('ws_1', { ref: 'aur_a' }, 'admin');
+            expect(mockBridge.request).toHaveBeenLastCalledWith(...entityOp(entity_ops_1.PLUGIN_WORKSPACES_ENTITY_ID, 'update_member', {
+                workspaceId: 'ws_1',
+                ref: 'aur_a',
+                role: 'admin',
+            }));
+            mockBridge.request.mockResolvedValue(output({}));
+            await useFiasWorkspaces().removeMember('ws_1', 'alice');
+            expect(mockBridge.request).toHaveBeenLastCalledWith(...entityOp(entity_ops_1.PLUGIN_WORKSPACES_ENTITY_ID, 'remove_member', {
+                workspaceId: 'ws_1',
+                username: 'alice',
+            }));
+        });
+    });
+    describe('useFiasWorkspaces() member target guard (ADR-040 §4)', () => {
+        it('a missing target (m.username on a ref roster) is a clear error, not a TypeError', async () => {
+            const { useFiasWorkspaces } = require('./hooks');
+            await expect(useFiasWorkspaces().removeMember('ws_1', undefined)).rejects.toThrow(/name the member by \{ ref \}/);
+            expect(mockBridge.request).not.toHaveBeenCalled();
+        });
+    });
+    describe('useFiasWorkspaces().resolvePeople (ADR-040)', () => {
+        it('sends the refs and the workspace, and returns the names or nulls in order', async () => {
+            const { useFiasWorkspaces } = require('./hooks');
+            const people = [{ ref: 'aur_a', displayName: 'Ada', avatar: null }, null];
+            mockBridge.request.mockResolvedValue(output({ people }));
+            await expect(useFiasWorkspaces().resolvePeople(['aur_a', 'aur_b'], 'ws_1')).resolves.toEqual(people);
+            expect(mockBridge.request).toHaveBeenCalledWith(...entityOp(entity_ops_1.PLUGIN_WORKSPACES_ENTITY_ID, 'resolve_people', {
+                refs: ['aur_a', 'aur_b'],
+                workspaceId: 'ws_1',
+            }));
+        });
+        it('an empty list answers [] without a call', async () => {
+            const { useFiasWorkspaces } = require('./hooks');
+            await expect(useFiasWorkspaces().resolvePeople([], 'ws_1')).resolves.toEqual([]);
+            expect(mockBridge.request).not.toHaveBeenCalled();
+        });
+        it('pages more than 100 refs and keeps their order', async () => {
+            const { useFiasWorkspaces } = require('./hooks');
+            const refs = Array.from({ length: 150 }, (_, i) => `aur_${i}`);
+            mockBridge.request
+                .mockResolvedValueOnce(output({ people: refs.slice(0, 100).map(() => null) }))
+                .mockResolvedValueOnce(output({
+                people: refs.slice(100).map((ref) => ({ ref, displayName: ref, avatar: null })),
+            }));
+            const people = await useFiasWorkspaces().resolvePeople(refs, 'ws_1');
+            expect(mockBridge.request).toHaveBeenCalledTimes(2);
+            expect(people).toHaveLength(150);
+            expect(people[99]).toBeNull();
+            expect(people[149]).toMatchObject({ ref: 'aur_149' });
+        });
+        it('omits workspaceId when none is given (own ref only)', async () => {
+            const { useFiasWorkspaces } = require('./hooks');
+            mockBridge.request.mockResolvedValue(output({ people: [null] }));
+            await useFiasWorkspaces().resolvePeople(['aur_a']);
+            expect(mockBridge.request).toHaveBeenCalledWith(...entityOp(entity_ops_1.PLUGIN_WORKSPACES_ENTITY_ID, 'resolve_people', { refs: ['aur_a'] }));
+        });
+    });
+    describe('useFiasWorkspaces().addPeople (ADR-040 Q12)', () => {
+        it('opens the host sheet with the workspace and suggested role, and returns who was added', async () => {
+            const { useFiasWorkspaces } = require('./hooks');
+            const added = [{ ref: 'aur_abcdefghijklmnopqrst', displayName: 'Ada', role: 'viewer' }];
+            mockBridge.request.mockResolvedValue({ added });
+            await expect(useFiasWorkspaces().addPeople('ws_1', { role: 'viewer' })).resolves.toEqual({
+                added,
+            });
+            expect(mockBridge.request).toHaveBeenCalledWith('client_entity_invoke', {
+                entityId: 'ent_intg_workspace_add_people_00',
+                input: { workspaceId: 'ws_1', role: 'viewer' },
+            }, expect.any(Number));
+        });
+        it("the host's typed refusal reaches the app as its code", async () => {
+            const { useFiasWorkspaces } = require('./hooks');
+            mockBridge.request.mockResolvedValue({
+                error: { code: 'SHEET_BUSY', message: 'Another request is waiting' },
+            });
+            await expect(useFiasWorkspaces().addPeople('ws_1')).rejects.toMatchObject({
+                code: 'SHEET_BUSY',
+            });
+        });
+        it('a host without the sheet answers ADD_PEOPLE_UNAVAILABLE', async () => {
+            const { useFiasWorkspaces } = require('./hooks');
+            const { FiasBridgeError } = jest.requireActual('./bridge');
+            mockBridge.request.mockRejectedValue(new FiasBridgeError('client_entity_invoke: no client-side executor registered for ent_intg_workspace_add_people_00', 'BRIDGE_ERROR'));
+            await expect(useFiasWorkspaces().addPeople('ws_1')).rejects.toMatchObject({
+                code: 'ADD_PEOPLE_UNAVAILABLE',
+            });
+        });
+        it('recognises the host code CLIENT_ENTITY_UNAVAILABLE, whatever the message', async () => {
+            const { useFiasWorkspaces } = require('./hooks');
+            const { FiasBridgeError } = jest.requireActual('./bridge');
+            mockBridge.request.mockRejectedValue(new FiasBridgeError('Not here', 'CLIENT_ENTITY_UNAVAILABLE'));
+            await expect(useFiasWorkspaces().addPeople('ws_1')).rejects.toMatchObject({
+                code: 'ADD_PEOPLE_UNAVAILABLE',
+            });
+        });
+        it('passes any other bridge error through unchanged', async () => {
+            const { useFiasWorkspaces } = require('./hooks');
+            const { FiasBridgeError } = jest.requireActual('./bridge');
+            mockBridge.request.mockRejectedValue(new FiasBridgeError('Permission denied: data:workspace', 'BRIDGE_ERROR'));
+            await expect(useFiasWorkspaces().addPeople('ws_1')).rejects.toMatchObject({
+                code: 'BRIDGE_ERROR',
+                message: 'Permission denied: data:workspace',
+            });
+        });
+    });
     // ADR-034 phase 0b. The real-render cases (stale answers across workspace
     // switches, the render before effects run, refetch) live in
     // use-fias-access.render.test.tsx, which CI runs through the package's
@@ -1015,7 +1134,7 @@ describe('SDK hooks', () => {
             await expect(state.openAccessDialog()).rejects.toMatchObject({ code: 'NOT_IN_WORKSPACE' });
         });
     });
-    describe('useCreativeLibrary().pick (ADR-035 D8)', () => {
+    describe('useCreativeLibrary().pick (ADR-037 D8)', () => {
         const PICKED = {
             item: { itemId: 'vci_' + 'a'.repeat(32), kind: 'style', name: 'Ink', version: 2 },
         };
@@ -1053,6 +1172,71 @@ describe('SDK hooks', () => {
             });
         });
     });
+    describe('useOpener (ADR-037 D8)', () => {
+        const FILE = 'doc_' + 'a'.repeat(32);
+        const opener = { kind: 'forge', name: 'My Arche' };
+        const CHROME = {
+            focusMode: false,
+            focusModeAvailable: false,
+            sidebarAvailable: false,
+            sidebarCollapsed: false,
+            hostExpandedBar: true,
+            hostExpandButton: true,
+            opener,
+        };
+        it('names where the person came from, without taking the chrome over', () => {
+            mockBridge.getChrome.mockReturnValue(CHROME);
+            const { useOpener } = require('./hooks');
+            expect(useOpener().opener).toEqual(opener);
+            expect(mockBridge.setChrome).not.toHaveBeenCalled();
+        });
+        it('returns there only when there is an opener', () => {
+            const { useOpener } = require('./hooks');
+            useOpener().returnTo();
+            expect(mockBridge.navigateHost).not.toHaveBeenCalled();
+            mockBridge.getChrome.mockReturnValue(CHROME);
+            useOpener().returnTo();
+            expect(mockBridge.navigateHost).toHaveBeenCalledWith('opener');
+        });
+        it('offers a file through the host’s sheet, waiting on the person', async () => {
+            mockBridge.getChrome.mockReturnValue(CHROME);
+            mockBridge.request.mockResolvedValue({ sent: true, name: 'pumpkin.png' });
+            const { useOpener } = require('./hooks');
+            await expect(useOpener().send({ fileId: FILE, name: 'pumpkin.png' })).resolves.toEqual({
+                sent: true,
+                name: 'pumpkin.png',
+            });
+            const [op, payload, timeout] = mockBridge.request.mock.calls[0];
+            expect(op).toBe('client_entity_invoke');
+            expect(payload).toEqual({
+                entityId: entity_ops_1.SEND_TO_OPENER_ENTITY_ID,
+                input: { fileId: FILE, name: 'pumpkin.png' },
+            });
+            expect(timeout).toBeGreaterThanOrEqual(5 * 60 * 1000);
+        });
+        it('refuses with NO_OPENER when nothing opened this arche, asking nothing', async () => {
+            const { useOpener } = require('./hooks');
+            const api = useOpener();
+            expect(api.opener).toBeNull();
+            await expect(api.send({ fileId: FILE })).rejects.toMatchObject({ code: 'NO_OPENER' });
+            expect(mockBridge.request).not.toHaveBeenCalled();
+        });
+        it('turns a refusal into a typed error, and a host without it into SEND_UNAVAILABLE', async () => {
+            mockBridge.getChrome.mockReturnValue(CHROME);
+            const { useOpener } = require('./hooks');
+            mockBridge.request.mockResolvedValueOnce({
+                error: { code: 'SHEET_BUSY', message: 'Another request is waiting' },
+            });
+            await expect(useOpener().send({ fileId: FILE })).rejects.toMatchObject({
+                code: 'SHEET_BUSY',
+            });
+            const { FiasBridgeError } = jest.requireActual('./bridge');
+            mockBridge.request.mockRejectedValueOnce(new FiasBridgeError('no client-side executor registered for x', 'BRIDGE_ERROR'));
+            await expect(useOpener().send({ fileId: FILE })).rejects.toMatchObject({
+                code: 'SEND_UNAVAILABLE',
+            });
+        });
+    });
     describe('useFiasConnections', () => {
         it('lists through the connections entity', async () => {
             const { useFiasConnections } = require('./hooks');