@forge/react 9.1.4 → 9.2.0-next.1

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @forge/react
 
+## 9.2.0-next.1
+
+### Minor Changes
+
+- be57ee6: Created hooks for the package:
+  - useProductContext: outputs the app's environment context via @forge/bridge's view.getContext()
+  - useConfig: requests for product environment context and extracts the app's config (if available)
+
+## 9.2.0-next.0
+
+### Minor Changes
+
+- 0cbc4ee: creates useSpaceProperty and useContentProperty hooks for UI kit 2
+
+  - useSpaceProperty:
+    - manages a Confluence space's property (via Confluence v2 API)
+    - requires the following scopes:
+      - read:space:confluence
+      - write:space:confluence
+  - useContentProperty
+    - manages a Confluence page's property (via Confluence v2 API)
+    - requires the following scopes
+      - read:page:confluence
+      - write:page:confluence
+
 ## 9.1.4
 
 ### Patch Changes

package/out/__test__/testUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testUtils.d.ts","sourceRoot":"","sources":["../../src/__test__/testUtils.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,oBAAY,UAAU,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,cAAc,CAAA;CAAE,CAAC;AAC/D,aAAK,WAAW,GAAG,MAAM,UAAU,EAAE,CAAC;AAEtC,aAAK,iBAAiB,GAAG,CAAC,WAAW,EAAE,UAAU,EAAE,KAAK,UAAU,GAAG,IAAI,CAAC;AAC1E,aAAK,yBAAyB,GAAG,CAAC,WAAW,EAAE,UAAU,EAAE,KAAK,QAAQ,GAAG,IAAI,CAAC;AAChF,aAAK,qBAAqB,GAAG,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,EAAE,GAAG,EAAE,MAAM,KAAK,QAAQ,GAAG,SAAS,CAAC;AAE9F,aAAK,cAAc,GAAG;IACpB,QAAQ,EAAE,QAAQ,CAAC;CACpB,CAAC;AAMF,eAAO,MAAM,WAAW,EAAE,WAWzB,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,iBAK/B,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,yBAMvC,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,qBAkBnC,CAAC"}
+{"version":3,"file":"testUtils.d.ts","sourceRoot":"","sources":["../../src/__test__/testUtils.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,oBAAY,UAAU,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,cAAc,CAAA;CAAE,CAAC;AAC/D,aAAK,WAAW,GAAG,MAAM,UAAU,EAAE,CAAC;AAEtC,aAAK,iBAAiB,GAAG,CAAC,WAAW,EAAE,UAAU,EAAE,KAAK,UAAU,GAAG,IAAI,CAAC;AAC1E,aAAK,yBAAyB,GAAG,CAAC,WAAW,EAAE,UAAU,EAAE,KAAK,QAAQ,GAAG,IAAI,CAAC;AAChF,aAAK,qBAAqB,GAAG,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,EAAE,GAAG,EAAE,MAAM,KAAK,QAAQ,GAAG,SAAS,CAAC;AAE9F,aAAK,cAAc,GAAG;IACpB,QAAQ,EAAE,QAAQ,CAAC;CACpB,CAAC;AAMF,eAAO,MAAM,WAAW,EAAE,WAYzB,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,iBAK/B,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,yBAMvC,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,qBAkBnC,CAAC"}

package/out/hooks/__test__/confluenceEntity.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=confluenceEntity.test.d.ts.map

package/out/hooks/__test__/confluenceEntity.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confluenceEntity.test.d.ts","sourceRoot":"","sources":["../../../src/hooks/__test__/confluenceEntity.test.ts"],"names":[],"mappings":""}

package/out/hooks/__test__/confluenceEntity.test.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mockRequestConf = jest.fn();
+const mockGetContext = jest.fn(async () => mockPropertyHook_1.mockConfContext);
+const confluenceEntity_1 = require("../confluenceEntity");
+const mockPropertyHook_1 = require("./mockPropertyHook");
+jest.mock('@forge/bridge', () => ({
+    requestConfluence: mockRequestConf,
+    view: { getContext: mockGetContext }
+}));
+describe('confAPIEndpoints string generation, given an entityType, productContext and required property data', () => {
+    const spaceEndpoints = (0, confluenceEntity_1.confAPIEndpoints)({ entityType: 'Space', context: mockPropertyHook_1.mockConfContext });
+    const contentEndpoints = (0, confluenceEntity_1.confAPIEndpoints)({ entityType: 'Content', context: mockPropertyHook_1.mockConfContext });
+    it('should generate the expected property create URL', () => {
+        expect(spaceEndpoints.create()).toEqual('/wiki/api/v2/spaces/MOCK_SPACE_ID/properties');
+        expect(contentEndpoints.create()).toEqual('/wiki/api/v2/pages/MOCK_PAGE_ID/properties');
+    });
+    it('should generate the expected property get URL', () => {
+        expect(spaceEndpoints.fetch('MOCK_PROP_KEY')).toEqual('/wiki/api/v2/spaces/MOCK_SPACE_ID/properties?key=MOCK_PROP_KEY');
+        expect(contentEndpoints.fetch('MOCK_PROP_KEY')).toEqual('/wiki/api/v2/pages/MOCK_PAGE_ID/properties?key=MOCK_PROP_KEY');
+    });
+    it('should generate the expected property update URL', () => {
+        expect(spaceEndpoints.update('MOCK_PROP_ID')).toEqual('/wiki/api/v2/spaces/MOCK_SPACE_ID/properties/MOCK_PROP_ID');
+        expect(contentEndpoints.update('MOCK_PROP_ID')).toEqual('/wiki/api/v2/pages/MOCK_PAGE_ID/properties/MOCK_PROP_ID');
+    });
+    it('should generate the expected property delete URL', () => {
+        expect(spaceEndpoints.delete('MOCK_PROP_ID')).toEqual('/wiki/api/v2/spaces/MOCK_SPACE_ID/properties/MOCK_PROP_ID');
+        expect(contentEndpoints.delete('MOCK_PROP_ID')).toEqual('/wiki/api/v2/pages/MOCK_PAGE_ID/properties/MOCK_PROP_ID');
+    });
+    it('should throw an error if spaceId not available', () => {
+        expect(() => (0, confluenceEntity_1.confAPIEndpoints)({ entityType: 'Space', context: { extension: {} } })).toThrow('Space properties not available for this app.');
+        expect(() => (0, confluenceEntity_1.confAPIEndpoints)({ entityType: 'Content', context: { extension: {} } })).toThrow('Content properties not available for this app.');
+    });
+});
+describe('confluenceEntity', () => {
+    const contentEntity = (0, confluenceEntity_1.confluenceEntity)({
+        entityType: 'Content',
+        origPropertyKey: 'MOCK_PROP_KEY',
+        initValue: mockPropertyHook_1.DEFAULT_PROP_VALUE
+    });
+    const contentEndpoints = (0, confluenceEntity_1.confAPIEndpoints)({ entityType: 'Content', context: mockPropertyHook_1.mockConfContext });
+    afterEach(() => jest.clearAllMocks());
+    describe('when running its get() output function', () => {
+        beforeAll(() => {
+            mockRequestConf.mockResolvedValue(mockPropertyHook_1.mockConfGetExistingRes);
+        });
+        it('should make a GET request with the right URL', async () => {
+            const contentGetUrl = contentEndpoints.fetch('forge-undefined-MOCK_PROP_KEY');
+            const contentGetBody = expect.objectContaining({ method: 'GET' });
+            await contentEntity.get();
+            expect(mockRequestConf).toHaveBeenNthCalledWith(1, contentGetUrl, contentGetBody);
+        });
+        it('if the property exists, it should return its value', async () => {
+            const output = await contentEntity.get();
+            expect(output).toEqual(mockPropertyHook_1.EXISTING_PROP_VALUE);
+            expect(mockRequestConf).toHaveBeenCalledTimes(1);
+        });
+        it('should throw an error if the GET request fails', async () => {
+            mockRequestConf.mockResolvedValueOnce(mockPropertyHook_1.mockConfFailedRes);
+            await expect(contentEntity.get).rejects.toThrow(`The request to fetch the content property (forge-undefined-MOCK_PROP_KEY) failed with status (400).`);
+        });
+        describe('if the property does not exist, it should create it', () => {
+            beforeEach(() => {
+                mockRequestConf.mockResolvedValueOnce(mockPropertyHook_1.mockConfGetNonExistentRes).mockResolvedValueOnce(mockPropertyHook_1.mockConfCreateRes);
+            });
+            it('should make a POST request to the API with the right URL and body', async () => {
+                const contentPostUrl = contentEndpoints.create();
+                const contentPostBody = expect.objectContaining({
+                    method: 'POST',
+                    body: JSON.stringify({ key: 'forge-undefined-MOCK_PROP_KEY', value: mockPropertyHook_1.DEFAULT_PROP_VALUE })
+                });
+                await contentEntity.get();
+                expect(mockRequestConf).toHaveBeenCalledTimes(2);
+                expect(mockRequestConf).toHaveBeenNthCalledWith(2, contentPostUrl, contentPostBody);
+            });
+            it('should return the value of the created property (i.e. DEFAULT_PROP_VALUE value)', async () => {
+                const output = await contentEntity.get();
+                expect(output).toEqual(mockPropertyHook_1.DEFAULT_PROP_VALUE);
+            });
+            it('should throw an error if the POST request fails', async () => {
+                mockRequestConf.mockReset();
+                mockRequestConf.mockResolvedValueOnce(mockPropertyHook_1.mockConfGetNonExistentRes).mockResolvedValueOnce(mockPropertyHook_1.mockConfFailedRes);
+                await expect(contentEntity.get).rejects.toThrow(`The request to create the content property (forge-undefined-MOCK_PROP_KEY) failed with status (400).`);
+            });
+        });
+    });
+    describe('when running its update() output function', () => {
+        beforeEach(() => {
+            mockRequestConf.mockResolvedValueOnce(mockPropertyHook_1.mockConfGetExistingRes).mockResolvedValueOnce(mockPropertyHook_1.mockConfUpdateValueRes);
+        });
+        it('should fetch the original property, then make a PUT request with the right url and body', async () => {
+            const contentGetUrl = contentEndpoints.fetch('forge-undefined-MOCK_PROP_KEY');
+            const contentGetBody = expect.objectContaining({ method: 'GET' });
+            const contentPutUrl = contentEndpoints.update('MOCK_PROP_ID');
+            const valueUpdateStr = `"value":${mockPropertyHook_1.UPDATED_PROP_VALUE}`;
+            const versionUpdateStr = `"version":{"number":${mockPropertyHook_1.UPDATED_PROP_VALUE}`;
+            const contentPutBody = (updateStr) => expect.objectContaining({
+                body: expect.stringContaining(updateStr)
+            });
+            await contentEntity.update(mockPropertyHook_1.UPDATED_PROP_VALUE);
+            expect(mockRequestConf).toHaveBeenCalledTimes(2);
+            expect(mockRequestConf).toHaveBeenNthCalledWith(1, contentGetUrl, contentGetBody);
+            [valueUpdateStr, versionUpdateStr].forEach((updateStr) => {
+                expect(mockRequestConf).toHaveBeenNthCalledWith(2, contentPutUrl, contentPutBody(updateStr));
+            });
+        });
+        it('should return the value of the UPDATED_PROP_VALUE property when updating with solid value', async () => {
+            const valUpdate = await contentEntity.update(mockPropertyHook_1.UPDATED_PROP_VALUE);
+            expect(valUpdate).toEqual(mockPropertyHook_1.UPDATED_PROP_VALUE);
+        });
+        it('should return the value of the UPDATED_PROP_VALUE property when updating with setter function', async () => {
+            mockRequestConf.mockReset();
+            mockRequestConf.mockResolvedValueOnce(mockPropertyHook_1.mockConfGetExistingRes).mockResolvedValueOnce(mockPropertyHook_1.mockConfUpdateFunctionRes);
+            const updateCBFunc = (existingVal) => {
+                return existingVal * mockPropertyHook_1.UPDATED_PROP_VALUE;
+            };
+            const expectedResult = mockPropertyHook_1.EXISTING_PROP_VALUE * mockPropertyHook_1.UPDATED_PROP_VALUE;
+            const funcUpdate = await contentEntity.update(updateCBFunc);
+            expect(funcUpdate).toEqual(expectedResult);
+        });
+        it('should throw an error if the PUT request fails', async () => {
+            mockRequestConf.mockReset();
+            mockRequestConf.mockResolvedValueOnce(mockPropertyHook_1.mockConfGetExistingRes).mockResolvedValueOnce(mockPropertyHook_1.mockConfFailedRes);
+            await expect(() => contentEntity.update(mockPropertyHook_1.UPDATED_PROP_VALUE)).rejects.toThrow(`The request to update the content property (forge-undefined-MOCK_PROP_KEY) failed with status (400).`);
+        });
+    });
+    describe('when running its delete() output function', () => {
+        beforeEach(() => {
+            mockRequestConf.mockResolvedValueOnce(mockPropertyHook_1.mockConfGetExistingRes).mockResolvedValueOnce(mockPropertyHook_1.mockConfDeleteRes);
+        });
+        it('should fetch the original property, then make a DELETE request with the right url', async () => {
+            const contentGetUrl = contentEndpoints.fetch('forge-undefined-MOCK_PROP_KEY');
+            const contentGetBody = expect.objectContaining({ method: 'GET' });
+            const contentDeleteUrl = contentEndpoints.delete('MOCK_PROP_ID');
+            const contentDeleteBody = expect.objectContaining({ method: 'DELETE' });
+            await contentEntity.delete();
+            expect(mockRequestConf).toHaveBeenCalledTimes(2);
+            expect(mockRequestConf).toHaveBeenNthCalledWith(1, contentGetUrl, contentGetBody);
+            expect(mockRequestConf).toHaveBeenNthCalledWith(2, contentDeleteUrl, contentDeleteBody);
+            jest.clearAllMocks();
+        });
+        it('should throw an error if the DELETE request fails', async () => {
+            mockRequestConf.mockReset();
+            mockRequestConf.mockResolvedValueOnce(mockPropertyHook_1.mockConfGetExistingRes).mockResolvedValueOnce(mockPropertyHook_1.mockConfFailedRes);
+            await expect(contentEntity.delete).rejects.toThrow(`The request to delete the content property (forge-undefined-MOCK_PROP_KEY) failed with status (400).`);
+        });
+    });
+});

package/out/hooks/__test__/mockPropertyHook.d.ts

@@ -0,0 +1,56 @@
+import { EntityContext } from '../types';
+export declare const DEFAULT_PROP_VALUE: number, EXISTING_PROP_VALUE: number, UPDATED_PROP_VALUE: number;
+export declare const mockConfContext: EntityContext;
+export declare const mockConfFailedRes: {
+    ok: boolean;
+    status: number;
+};
+export declare const mockConfGetExistingRes: {
+    ok: boolean;
+    status: number;
+    json: () => {
+        results: {
+            id: string;
+            value: number;
+            version: {
+                number: number;
+            };
+        }[];
+    };
+};
+export declare const mockConfGetNonExistentRes: {
+    ok: boolean;
+    status: number;
+    json: () => {
+        results: never[];
+    };
+};
+export declare const mockConfCreateRes: {
+    ok: boolean;
+    status: number;
+    json: () => {
+        id: string;
+        value: number;
+    };
+};
+export declare const mockConfUpdateValueRes: {
+    ok: boolean;
+    status: number;
+    json: () => {
+        id: string;
+        value: number;
+    };
+};
+export declare const mockConfUpdateFunctionRes: {
+    ok: boolean;
+    status: number;
+    json: () => {
+        id: string;
+        value: number;
+    };
+};
+export declare const mockConfDeleteRes: {
+    ok: boolean;
+    status: number;
+};
+//# sourceMappingURL=mockPropertyHook.d.ts.map

package/out/hooks/__test__/mockPropertyHook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockPropertyHook.d.ts","sourceRoot":"","sources":["../../../src/hooks/__test__/mockPropertyHook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAGzC,eAAO,MAAO,kBAAkB,UAAE,mBAAmB,UAAE,kBAAkB,QAAa,CAAC;AAEvF,eAAO,MAAM,eAAe,EAAE,aAS7B,CAAC;AAKF,eAAO,MAAM,iBAAiB;;;CAG7B,CAAC;AACF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;CAMlC,CAAC;AACF,eAAO,MAAM,yBAAyB;;;;;;CAMrC,CAAC;AACF,eAAO,MAAM,iBAAiB;;;;;;;CAI7B,CAAC;AACF,eAAO,MAAM,sBAAsB;;;;;;;CAIlC,CAAC;AACF,eAAO,MAAM,yBAAyB;;;;;;;CAIrC,CAAC;AACF,eAAO,MAAM,iBAAiB;;;CAG7B,CAAC"}

package/out/hooks/__test__/mockPropertyHook.js

@@ -0,0 +1,52 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockConfDeleteRes = exports.mockConfUpdateFunctionRes = exports.mockConfUpdateValueRes = exports.mockConfCreateRes = exports.mockConfGetNonExistentRes = exports.mockConfGetExistingRes = exports.mockConfFailedRes = exports.mockConfContext = exports.UPDATED_PROP_VALUE = exports.EXISTING_PROP_VALUE = exports.DEFAULT_PROP_VALUE = void 0;
+_a = [1, 2, 3], exports.DEFAULT_PROP_VALUE = _a[0], exports.EXISTING_PROP_VALUE = _a[1], exports.UPDATED_PROP_VALUE = _a[2];
+exports.mockConfContext = {
+    extension: {
+        space: {
+            id: 'MOCK_SPACE_ID'
+        },
+        content: {
+            id: 'MOCK_PAGE_ID'
+        }
+    }
+};
+exports.mockConfFailedRes = {
+    ok: false,
+    status: 400
+};
+exports.mockConfGetExistingRes = {
+    ok: true,
+    status: 200,
+    json: () => ({
+        results: [{ id: 'MOCK_PROP_ID', value: exports.EXISTING_PROP_VALUE, version: { number: exports.EXISTING_PROP_VALUE } }]
+    })
+};
+exports.mockConfGetNonExistentRes = {
+    ok: true,
+    status: 200,
+    json: () => ({
+        results: []
+    })
+};
+exports.mockConfCreateRes = {
+    ok: true,
+    status: 201,
+    json: () => ({ id: 'MOCK_PROP_ID', value: exports.DEFAULT_PROP_VALUE })
+};
+exports.mockConfUpdateValueRes = {
+    ok: true,
+    status: 200,
+    json: () => ({ id: 'MOCK_PROP_ID', value: exports.UPDATED_PROP_VALUE })
+};
+exports.mockConfUpdateFunctionRes = {
+    ok: true,
+    status: 200,
+    json: () => ({ id: 'MOCK_PROP_ID', value: exports.UPDATED_PROP_VALUE * exports.EXISTING_PROP_VALUE })
+};
+exports.mockConfDeleteRes = {
+    ok: true,
+    status: 204
+};

package/out/hooks/__test__/useConfig.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=useConfig.test.d.ts.map

package/out/hooks/__test__/useConfig.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConfig.test.d.ts","sourceRoot":"","sources":["../../../src/hooks/__test__/useConfig.test.tsx"],"names":[],"mappings":""}

package/out/hooks/__test__/useConfig.test.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const jsx_runtime_1 = require("react/jsx-runtime");
+const mockGetContext = jest.fn(async () => null);
+const react_1 = tslib_1.__importStar(require("react"));
+const reconcilerTestRenderer_1 = tslib_1.__importDefault(require("../../__test__/reconcilerTestRenderer"));
+const useConfig_1 = require("../useConfig");
+const testUtils_1 = require("../../__test__/testUtils");
+jest.mock('@forge/bridge', () => ({
+    view: {
+        getContext: mockGetContext
+    }
+}));
+const MOCK_CONFIG = {
+    value: 1
+};
+const MOCK_CONTEXT_WITH_CONFIG = {
+    extension: {
+        config: MOCK_CONFIG
+    }
+};
+const MOCK_CONTEXT_NO_CONFIG = {
+    extension: {}
+};
+const configListener = jest.fn();
+const renderTest = async () => {
+    const Test = () => {
+        const config = (0, useConfig_1.useConfig)();
+        (0, react_1.useEffect)(() => configListener(config), [config]);
+        return (0, jsx_runtime_1.jsx)(react_1.default.Fragment, {});
+    };
+    await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(Test, {}));
+};
+describe('useConfig', () => {
+    beforeAll(() => (0, testUtils_1.setupBridge)());
+    afterEach(() => jest.clearAllMocks());
+    it('correctly outputs a given config', async () => {
+        mockGetContext.mockResolvedValue(MOCK_CONTEXT_WITH_CONFIG);
+        await renderTest();
+        expect(configListener).toHaveBeenCalledWith(expect.objectContaining(MOCK_CONFIG));
+    });
+    it('when there is no config, outputs undefined', async () => {
+        mockGetContext.mockResolvedValue(MOCK_CONTEXT_NO_CONFIG);
+        await renderTest();
+        expect(configListener.mock.calls[0][0]).toEqual(undefined);
+        expect(configListener).not.toHaveBeenNthCalledWith(2, expect.anything);
+    });
+});

package/out/hooks/__test__/useEntityProperty.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=useEntityProperty.test.d.ts.map

package/out/hooks/__test__/useEntityProperty.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEntityProperty.test.d.ts","sourceRoot":"","sources":["../../../src/hooks/__test__/useEntityProperty.test.tsx"],"names":[],"mappings":""}

package/out/hooks/__test__/useEntityProperty.test.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = tslib_1.__importStar(require("react"));
+const testUtils_1 = require("../../__test__/testUtils");
+const reconcilerTestRenderer_1 = tslib_1.__importDefault(require("../../__test__/reconcilerTestRenderer"));
+const mockPropertyHook_1 = require("./mockPropertyHook");
+const useEntityProperty_1 = require("../useEntityProperty");
+const mockRequest = jest.fn();
+const mockEntity = () => ({
+    get: async () => {
+        mockRequest('get');
+        return mockPropertyHook_1.EXISTING_PROP_VALUE;
+    },
+    update: async () => {
+        const response = await mockRequest('update');
+        if (!response.ok) {
+            throw new Error();
+        }
+        return mockPropertyHook_1.UPDATED_PROP_VALUE;
+    },
+    delete: async () => {
+        mockRequest('delete');
+    }
+});
+const useMockEntityProperty = () => {
+    const entityManager = (0, react_1.useMemo)(mockEntity, []);
+    return (0, useEntityProperty_1.useEntityProperty)(entityManager);
+};
+const propListener = jest.fn();
+var renderActions;
+(function (renderActions) {
+    renderActions[renderActions["noAction"] = 0] = "noAction";
+    renderActions[renderActions["toUpdate"] = 1] = "toUpdate";
+    renderActions[renderActions["toDelete"] = 2] = "toDelete";
+})(renderActions || (renderActions = {}));
+;
+const renderTest = async (action = renderActions.noAction, retryCount) => {
+    const Test = () => {
+        const [prop, setProp, delProp] = useMockEntityProperty();
+        (0, react_1.useEffect)(() => propListener(prop), [prop]);
+        (0, react_1.useEffect)(() => {
+            if (action === renderActions.toUpdate) {
+                void setProp(mockPropertyHook_1.UPDATED_PROP_VALUE, retryCount);
+            }
+            if (action === renderActions.toDelete) {
+                void delProp();
+            }
+        }, []);
+        return (0, jsx_runtime_1.jsx)(react_1.default.Fragment, {});
+    };
+    await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(Test, {}));
+};
+describe('useEntityProperty', () => {
+    beforeAll(testUtils_1.setupBridge);
+    beforeEach(() => {
+        mockRequest.mockResolvedValue(mockPropertyHook_1.mockConfGetExistingRes);
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('initial returned prop value', () => {
+        it("is acquired from the given entityManager's get() function", async () => {
+            await renderTest();
+            expect(mockRequest).toHaveBeenNthCalledWith(1, 'get');
+        });
+        it('is statefully and correctly rendered', async () => {
+            await renderTest();
+            expect(propListener).toHaveBeenNthCalledWith(1, undefined);
+            expect(propListener).toHaveBeenNthCalledWith(2, mockPropertyHook_1.EXISTING_PROP_VALUE);
+        });
+    });
+    describe('returned value-setting function', () => {
+        it("calls the given entityManager's update() function", async () => {
+            await renderTest(renderActions.toUpdate);
+            expect(mockRequest).toHaveBeenNthCalledWith(2, 'update');
+        });
+        it('updates the returned prop value statefully and correctly', async () => {
+            await renderTest(renderActions.toUpdate);
+            expect(propListener).toHaveBeenNthCalledWith(3, mockPropertyHook_1.UPDATED_PROP_VALUE);
+        });
+        it('makes 2 retries (by default) when initial attempt fails', async () => {
+            mockRequest.mockResolvedValue(() => mockPropertyHook_1.mockConfFailedRes);
+            await renderTest(renderActions.toUpdate);
+            expect(mockRequest).toHaveBeenNthCalledWith(2, 'update');
+            expect(mockRequest).toHaveBeenNthCalledWith(3, 'update');
+            expect(mockRequest).toHaveBeenNthCalledWith(4, 'update');
+            expect(mockRequest).not.toHaveBeenNthCalledWith(5, 'update');
+        });
+        it('stops retrying when a previous retry succeeds', async () => {
+            mockRequest.mockResolvedValueOnce(() => mockPropertyHook_1.mockConfFailedRes).mockResolvedValueOnce(() => mockPropertyHook_1.mockConfUpdateValueRes);
+            await renderTest(renderActions.toUpdate);
+            expect(mockRequest).toHaveBeenNthCalledWith(2, 'update');
+            expect(mockRequest).toHaveBeenNthCalledWith(3, 'update');
+            expect(mockRequest).not.toHaveBeenNthCalledWith(4, 'update');
+        });
+        it('makes custom number of retries (if given) when initial attempts fails', async () => {
+            const retryCount = 5;
+            mockRequest.mockResolvedValue(() => mockPropertyHook_1.mockConfFailedRes);
+            await renderTest(renderActions.toUpdate, retryCount);
+            for (let i = 2; i <= retryCount + 2; i++) {
+                expect(mockRequest).toHaveBeenNthCalledWith(i, 'update');
+            }
+            expect(mockRequest).not.toHaveBeenNthCalledWith(retryCount + 3, 'update');
+        });
+    });
+    describe('returned property-deleting function', () => {
+        it("calls the given entityManager's delete() function", async () => {
+            await renderTest(renderActions.toDelete);
+            expect(mockRequest).toHaveBeenNthCalledWith(2, 'delete');
+        });
+        it('updates the outputted prop value statefully to undefined', async () => {
+            await renderTest(renderActions.toDelete);
+            expect(propListener).toHaveBeenNthCalledWith(3, undefined);
+        });
+    });
+});

package/out/hooks/__test__/useProductContext.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=useProductContext.test.d.ts.map

package/out/hooks/__test__/useProductContext.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useProductContext.test.d.ts","sourceRoot":"","sources":["../../../src/hooks/__test__/useProductContext.test.tsx"],"names":[],"mappings":""}

package/out/hooks/__test__/useProductContext.test.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const jsx_runtime_1 = require("react/jsx-runtime");
+const mockGetContext = jest.fn(async () => null);
+const useProductContext_1 = require("../useProductContext");
+const react_1 = tslib_1.__importStar(require("react"));
+const testUtils_1 = require("../../__test__/testUtils");
+const reconcilerTestRenderer_1 = tslib_1.__importDefault(require("../../__test__/reconcilerTestRenderer"));
+jest.mock('@forge/bridge', () => ({
+    view: {
+        getContext: mockGetContext
+    }
+}));
+const MOCK_CONTEXT = {
+    accountId: 'client-accountId',
+    cloudId: 'DUMMY-cloudId',
+    extension: { contentId: 'DUMMY-contentId' },
+    license: undefined,
+    localId: 'DUMMY-localId',
+    locale: 'DUMMY-locale',
+    moduleKey: 'DUMMY-moduleKey',
+    siteUrl: 'DUMMY-siteUrl',
+    timezone: 'DUMMY-timezone'
+};
+const prodContListener = jest.fn();
+const renderTest = async () => {
+    const Test = () => {
+        const prodCont = (0, useProductContext_1.useProductContext)();
+        (0, react_1.useEffect)(() => prodContListener(prodCont), [prodCont]);
+        return (0, jsx_runtime_1.jsx)(react_1.default.Fragment, {});
+    };
+    await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(Test, {}));
+};
+describe('useProductContext', () => {
+    const LOAD_TIME = 500;
+    beforeAll(() => (0, testUtils_1.setupBridge)());
+    afterEach(() => jest.clearAllMocks());
+    it("automatically fetches data via bridge's view.getContext()", async () => {
+        await renderTest();
+        expect(mockGetContext).toHaveBeenCalled();
+    });
+    it('corrently renders an expected ProductContext that is available upon load', async () => {
+        mockGetContext.mockResolvedValue(MOCK_CONTEXT);
+        await renderTest();
+        expect(prodContListener.mock.calls[1][0]).toEqual(MOCK_CONTEXT);
+    });
+    it('corrently renders an expected ProductContext that takes time to load', async () => {
+        mockGetContext.mockImplementation(async () => {
+            await new Promise((res) => setTimeout(res, LOAD_TIME));
+            return MOCK_CONTEXT;
+        });
+        await renderTest();
+        expect(prodContListener).not.toHaveBeenNthCalledWith(2, expect.anything());
+        await new Promise((res) => setTimeout(res, LOAD_TIME * 2));
+        expect(prodContListener.mock.calls[1][0]).toEqual(MOCK_CONTEXT);
+    }, LOAD_TIME * 3);
+});

package/out/hooks/confluenceEntity.d.ts

@@ -0,0 +1,11 @@
+import { ConfEndpointInitializer, ManagePropsData, ConfluenceEntityType, EntityManager } from './types';
+export declare const confAPIEndpoints: ({ entityType, context }: ConfEndpointInitializer) => {
+    create: () => string;
+    fetch: (propertyKey: string) => string;
+    update: (propertyId: string) => string;
+    delete: (propertyId: string) => string;
+};
+export declare const confluenceEntity: <PropValue>({ entityType, origPropertyKey, initValue }: ManagePropsData<PropValue> & {
+    entityType: ConfluenceEntityType;
+}) => EntityManager<PropValue>;
+//# sourceMappingURL=confluenceEntity.d.ts.map

package/out/hooks/confluenceEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confluenceEntity.d.ts","sourceRoot":"","sources":["../../src/hooks/confluenceEntity.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,uBAAuB,EAEvB,eAAe,EACf,oBAAoB,EACpB,aAAa,EAEd,MAAM,SAAS,CAAC;AAMjB,eAAO,MAAM,gBAAgB,4BAA6B,uBAAuB;;yBAqBxD,MAAM;yBACN,MAAM;yBACN,MAAM;CAE9B,CAAC;AAEF,eAAO,MAAM,gBAAgB;gBAIiB,oBAAoB;8BAqGjE,CAAC"}