@forge/react 11.3.0-next.1 → 11.4.0-next.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @forge/react
 
+## 11.4.0-next.0
+
+### Minor Changes
+
+- 582f25c: Attach event for content property updated by forge/react hook"
+
+## 11.3.0
+
+### Minor Changes
+
+- 1fe70bc: Add package.json exports configuration for improved TypeScript module resolution in forge-react package.
+
+### Patch Changes
+
+- 0371b03: Update type import from @forge/bridge
+- Updated dependencies [8e77d28]
+- Updated dependencies [185f844]
+  - @forge/bridge@5.5.0
+
 ## 11.3.0-next.1
 
 ### Patch Changes

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

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

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

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

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

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const jsx_runtime_1 = require("react/jsx-runtime");
+// Mock event system - must be defined before jest.mock() calls
+const listeners = new Map();
+const mockEvents = {
+    emit: jest.fn((event, data) => {
+        if (listeners.has(event)) {
+            listeners.get(event)?.forEach((callback) => callback(data));
+        }
+        return Promise.resolve();
+    }),
+    on: jest.fn((event, callback) => {
+        if (!listeners.has(event)) {
+            listeners.set(event, []);
+        }
+        listeners.get(event)?.push(callback);
+    }),
+    clearListeners: (event) => {
+        listeners.delete(event);
+    }
+};
+// Mock data - define before imports
+const MOCK_PROPERTY_KEY = 'test-property-key';
+const MOCK_INIT_VALUE = { count: 0 };
+const MOCK_EXISTING_VALUE = { count: 5 };
+const MOCK_UPDATED_VALUE = { count: 10 };
+// Mock functions - define before imports
+const mockUpdateProp = jest.fn();
+const mockDeleteProp = jest.fn();
+const mockConfluenceEntity = jest.fn(() => ({
+    get: jest.fn(),
+    update: jest.fn(),
+    delete: jest.fn()
+}));
+const reconcilerTestRenderer_1 = tslib_1.__importDefault(require("../../__test__/reconcilerTestRenderer"));
+const testUtils_1 = require("../../__test__/testUtils");
+const useContentProperty_1 = require("../useContentProperty");
+const useEntityProperty_1 = require("../useEntityProperty");
+// Mock modules after imports
+jest.mock('@forge/bridge', () => ({
+    events: mockEvents
+}));
+jest.mock('../useEntityProperty', () => ({
+    useEntityProperty: jest.fn(() => [MOCK_EXISTING_VALUE, mockUpdateProp, mockDeleteProp])
+}));
+jest.mock('../confluenceEntity', () => ({
+    confluenceEntity: mockConfluenceEntity
+}));
+describe('useContentProperty', () => {
+    beforeEach(() => {
+        // Clear only specific mocks, not all mocks to preserve function references
+        mockUpdateProp.mockClear();
+        mockDeleteProp.mockClear();
+        mockConfluenceEntity.mockClear();
+        mockEvents.emit.mockClear();
+        mockEvents.on.mockClear();
+        mockEvents.clearListeners('FORGE_CONTENT_PROPERTY_UPDATED');
+        (0, testUtils_1.setupBridge)(); // Set up global bridge for tests
+    });
+    it('should initialize confluenceEntity with correct parameters', async () => {
+        const TestComponent = () => {
+            (0, useContentProperty_1.useContentProperty)(MOCK_PROPERTY_KEY, MOCK_INIT_VALUE);
+            return null;
+        };
+        await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+        expect(mockConfluenceEntity).toHaveBeenCalledWith({
+            entityType: 'Content',
+            origPropertyKey: MOCK_PROPERTY_KEY,
+            initValue: MOCK_INIT_VALUE
+        });
+    });
+    it('should call useEntityProperty with the entity manager', async () => {
+        const TestComponent = () => {
+            (0, useContentProperty_1.useContentProperty)(MOCK_PROPERTY_KEY, MOCK_INIT_VALUE);
+            return null;
+        };
+        await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+        expect(useEntityProperty_1.useEntityProperty).toHaveBeenCalledWith({
+            entityManager: expect.any(Object)
+        });
+    });
+    it('should return property value, update function, and delete function', async () => {
+        let hookResult = [];
+        const TestComponent = () => {
+            hookResult = (0, useContentProperty_1.useContentProperty)(MOCK_PROPERTY_KEY, MOCK_INIT_VALUE);
+            return null;
+        };
+        await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+        expect(hookResult).toHaveLength(3);
+        expect(hookResult[0]).toBe(MOCK_EXISTING_VALUE);
+        expect(typeof hookResult[1]).toBe('function');
+        expect(typeof hookResult[2]).toBe('function');
+        expect(hookResult[2]).toBe(mockDeleteProp);
+    });
+    it('should emit event when property update is successful', async () => {
+        mockUpdateProp.mockResolvedValueOnce(MOCK_UPDATED_VALUE);
+        let updateFunction = jest.fn();
+        const TestComponent = () => {
+            const [, updateProp] = (0, useContentProperty_1.useContentProperty)(MOCK_PROPERTY_KEY, MOCK_INIT_VALUE);
+            updateFunction = updateProp;
+            return null;
+        };
+        await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+        await updateFunction(MOCK_UPDATED_VALUE);
+        expect(mockUpdateProp).toHaveBeenCalledWith(MOCK_UPDATED_VALUE, undefined);
+        expect(mockEvents.emit).toHaveBeenCalledWith('FORGE_CONTENT_PROPERTY_UPDATED', {
+            propertyKey: MOCK_PROPERTY_KEY,
+            valueUpdate: MOCK_UPDATED_VALUE
+        });
+    });
+    it('should emit event when property update with retry count is successful', async () => {
+        mockUpdateProp.mockResolvedValueOnce(MOCK_UPDATED_VALUE);
+        const retryCount = 5;
+        let updateFunction = jest.fn();
+        const TestComponent = () => {
+            const [, updateProp] = (0, useContentProperty_1.useContentProperty)(MOCK_PROPERTY_KEY, MOCK_INIT_VALUE);
+            updateFunction = updateProp;
+            return null;
+        };
+        await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+        await updateFunction(MOCK_UPDATED_VALUE, retryCount);
+        expect(mockUpdateProp).toHaveBeenCalledWith(MOCK_UPDATED_VALUE, retryCount);
+        expect(mockEvents.emit).toHaveBeenCalledWith('FORGE_CONTENT_PROPERTY_UPDATED', {
+            propertyKey: MOCK_PROPERTY_KEY,
+            valueUpdate: MOCK_UPDATED_VALUE
+        });
+    });
+    it('should emit event when property update with function updater is successful', async () => {
+        const updaterFunction = (prev) => ({ ...prev, count: prev.count + 1 });
+        mockUpdateProp.mockResolvedValueOnce(MOCK_UPDATED_VALUE);
+        let updateFunction = jest.fn();
+        const TestComponent = () => {
+            const [, updateProp] = (0, useContentProperty_1.useContentProperty)(MOCK_PROPERTY_KEY, MOCK_INIT_VALUE);
+            updateFunction = updateProp;
+            return null;
+        };
+        await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+        await updateFunction(updaterFunction);
+        expect(mockUpdateProp).toHaveBeenCalledWith(updaterFunction, undefined);
+        expect(mockEvents.emit).toHaveBeenCalledWith('FORGE_CONTENT_PROPERTY_UPDATED', {
+            propertyKey: MOCK_PROPERTY_KEY,
+            valueUpdate: updaterFunction
+        });
+    });
+    it('should NOT emit event when property update fails', async () => {
+        const updateError = new Error('Update failed');
+        mockUpdateProp.mockRejectedValueOnce(updateError);
+        let updateFunction = jest.fn();
+        let caughtError;
+        const TestComponent = () => {
+            const [, updateProp] = (0, useContentProperty_1.useContentProperty)(MOCK_PROPERTY_KEY, MOCK_INIT_VALUE);
+            updateFunction = updateProp;
+            return null;
+        };
+        await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+        try {
+            await updateFunction(MOCK_UPDATED_VALUE);
+        }
+        catch (error) {
+            caughtError = error;
+        }
+        expect(mockUpdateProp).toHaveBeenCalledWith(MOCK_UPDATED_VALUE, undefined);
+        expect(mockEvents.emit).not.toHaveBeenCalled();
+        expect(caughtError).toBe(updateError);
+    });
+    it('should re-throw error when property update fails', async () => {
+        const updateError = new Error('Network error');
+        mockUpdateProp.mockRejectedValueOnce(updateError);
+        let updateFunction = jest.fn();
+        const TestComponent = () => {
+            const [, updateProp] = (0, useContentProperty_1.useContentProperty)(MOCK_PROPERTY_KEY, MOCK_INIT_VALUE);
+            updateFunction = updateProp;
+            return null;
+        };
+        await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+        await expect(updateFunction(MOCK_UPDATED_VALUE)).rejects.toThrow('Network error');
+    });
+    it('should pass through delete function without modification', async () => {
+        let deleteFunction = jest.fn();
+        const TestComponent = () => {
+            const [, , deleteProp] = (0, useContentProperty_1.useContentProperty)(MOCK_PROPERTY_KEY, MOCK_INIT_VALUE);
+            deleteFunction = deleteProp;
+            return null;
+        };
+        await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+        expect(deleteFunction).toBe(mockDeleteProp);
+    });
+    it('should memoize entity manager to prevent unnecessary re-creation', async () => {
+        let renderCount = 0;
+        const TestComponent = ({ propKey }) => {
+            renderCount++;
+            (0, useContentProperty_1.useContentProperty)(propKey, MOCK_INIT_VALUE);
+            return null;
+        };
+        // First render
+        const renderer = await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, { propKey: MOCK_PROPERTY_KEY }));
+        const firstCallCount = mockConfluenceEntity.mock.calls.length;
+        // Re-render with same key
+        await renderer.update((0, jsx_runtime_1.jsx)(TestComponent, { propKey: MOCK_PROPERTY_KEY }));
+        const secondCallCount = mockConfluenceEntity.mock.calls.length;
+        expect(renderCount).toBe(2);
+        // Verify the entity manager is called with same parameters, ensuring proper memoization setup
+        expect(mockConfluenceEntity).toHaveBeenCalledWith({
+            entityType: 'Content',
+            origPropertyKey: MOCK_PROPERTY_KEY,
+            initValue: MOCK_INIT_VALUE
+        });
+        // Note: Due to test renderer behavior, entity manager may be recreated during unmount/remount
+        expect(secondCallCount).toBeGreaterThanOrEqual(firstCallCount);
+    });
+    it('should handle different property keys correctly', async () => {
+        const propertyKey1 = 'property-1';
+        const propertyKey2 = 'property-2';
+        const value1 = { data: 'test1' };
+        const value2 = { data: 'test2' };
+        mockUpdateProp.mockResolvedValue(value1);
+        let updateFunction1 = jest.fn();
+        let updateFunction2 = jest.fn();
+        const TestComponent = () => {
+            const [, updateProp1] = (0, useContentProperty_1.useContentProperty)(propertyKey1, value1);
+            const [, updateProp2] = (0, useContentProperty_1.useContentProperty)(propertyKey2, value2);
+            updateFunction1 = updateProp1;
+            updateFunction2 = updateProp2;
+            return null;
+        };
+        await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+        await updateFunction1(value1);
+        await updateFunction2(value2);
+        expect(mockEvents.emit).toHaveBeenCalledWith('FORGE_CONTENT_PROPERTY_UPDATED', {
+            propertyKey: propertyKey1,
+            valueUpdate: value1
+        });
+        expect(mockEvents.emit).toHaveBeenCalledWith('FORGE_CONTENT_PROPERTY_UPDATED', {
+            propertyKey: propertyKey2,
+            valueUpdate: value2
+        });
+    });
+    it('should handle async event emission without blocking', async () => {
+        // Make event.emit slow to ensure it doesn't block the update
+        mockEvents.emit.mockImplementationOnce(() => new Promise((resolve) => setTimeout(resolve, 100)));
+        mockUpdateProp.mockResolvedValueOnce(MOCK_UPDATED_VALUE);
+        let updateFunction = jest.fn();
+        const TestComponent = () => {
+            const [, updateProp] = (0, useContentProperty_1.useContentProperty)(MOCK_PROPERTY_KEY, MOCK_INIT_VALUE);
+            updateFunction = updateProp;
+            return null;
+        };
+        await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+        const startTime = Date.now();
+        await updateFunction(MOCK_UPDATED_VALUE);
+        const endTime = Date.now();
+        // Update should complete quickly (not wait for event emission)
+        expect(endTime - startTime).toBeLessThan(50);
+        expect(mockUpdateProp).toHaveBeenCalled();
+        expect(mockEvents.emit).toHaveBeenCalled();
+    });
+    it('should preserve update function reference between renders', async () => {
+        let updateFunction1 = jest.fn();
+        let updateFunction2 = jest.fn();
+        const TestComponent = ({ renderKey }) => {
+            const [, updateProp] = (0, useContentProperty_1.useContentProperty)(MOCK_PROPERTY_KEY, MOCK_INIT_VALUE);
+            if (renderKey === 1)
+                updateFunction1 = updateProp;
+            if (renderKey === 2)
+                updateFunction2 = updateProp;
+            return null;
+        };
+        const renderer = await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, { renderKey: 1 }));
+        await renderer.update((0, jsx_runtime_1.jsx)(TestComponent, { renderKey: 2 }));
+        // Verify both functions exist and are callable
+        expect(typeof updateFunction1).toBe('function');
+        expect(typeof updateFunction2).toBe('function');
+        // Note: Function reference stability depends on underlying useEntityProperty mock stability
+    });
+});

package/out/hooks/useContentProperty.d.ts

@@ -1,3 +1,4 @@
+import type { ValueUpdate } from './types';
 /**
  * This function manages the content properties of a Confluence page where the app is installed.
  * @param propertyKey Name (key) of the property
@@ -7,5 +8,5 @@
  *  2. A function to update the property value (with another value or an updater function). If an initial update fails, it automatically tries to update for another <retryCount> times (default 2).
  *  3. A function to delete the property.
  */
-export declare const useContentProperty: <PropValue>(propertyKey: string, initValue: PropValue) => readonly [PropValue | undefined, (valueUpdate: import("./types/entityProps").ValueUpdate<PropValue>, retryCount?: number) => Promise<void>, () => Promise<void>];
+export declare const useContentProperty: <PropValue>(propertyKey: string, initValue: PropValue) => readonly [PropValue | undefined, (valueUpdate: ValueUpdate<PropValue>, retryCount?: number) => Promise<void>, () => Promise<void>];
 //# sourceMappingURL=useContentProperty.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useContentProperty.d.ts","sourceRoot":"","sources":["../../src/hooks/useContentProperty.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,2BAA4B,MAAM,2LAWhE,CAAC"}
+{"version":3,"file":"useContentProperty.d.ts","sourceRoot":"","sources":["../../src/hooks/useContentProperty.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,2BAA4B,MAAM,+GAcJ,MAAM,wCAUlE,CAAC"}

package/out/hooks/useContentProperty.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useContentProperty = void 0;
 const react_1 = require("react");
+const bridge_1 = require("@forge/bridge");
 const confluenceEntity_1 = require("./confluenceEntity");
 const useEntityProperty_1 = require("./useEntityProperty");
 /**
@@ -18,7 +19,14 @@ const useContentProperty = (propertyKey, initValue) => {
         entityType: 'Content',
         origPropertyKey: propertyKey,
         initValue
-    }), []);
-    return (0, useEntityProperty_1.useEntityProperty)({ entityManager });
+    }), [propertyKey, initValue]);
+    const [propValue, updateProp, deleteProp] = (0, useEntityProperty_1.useEntityProperty)({ entityManager });
+    const updatePropWithEvent = (0, react_1.useCallback)(async (valueUpdate, retryCount) => {
+        const success = await updateProp(valueUpdate, retryCount);
+        if (success) {
+            void bridge_1.events.emit('FORGE_CONTENT_PROPERTY_UPDATED', { propertyKey, valueUpdate });
+        }
+    }, [updateProp, propertyKey]);
+    return [propValue, updatePropWithEvent, deleteProp];
 };
 exports.useContentProperty = useContentProperty;

package/out/hooks/useEntityProperty.d.ts

@@ -1,3 +1,3 @@
 import type { ValueUpdate, EntityPropertyUseParams } from './types';
-export declare const useEntityProperty: <PropValue>({ entityManager, defaultRetryCount }: EntityPropertyUseParams<PropValue>) => readonly [PropValue | undefined, (valueUpdate: ValueUpdate<PropValue>, retryCount?: number) => Promise<void>, () => Promise<void>];
+export declare const useEntityProperty: <PropValue>({ entityManager, defaultRetryCount }: EntityPropertyUseParams<PropValue>) => readonly [PropValue | undefined, (valueUpdate: ValueUpdate<PropValue>, retryCount?: number) => Promise<boolean>, () => Promise<void>];
 //# sourceMappingURL=useEntityProperty.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useEntityProperty.d.ts","sourceRoot":"","sources":["../../src/hooks/useEntityProperty.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAGpE,eAAO,MAAM,iBAAiB,6NAgD7B,CAAC"}
+{"version":3,"file":"useEntityProperty.d.ts","sourceRoot":"","sources":["../../src/hooks/useEntityProperty.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAGpE,eAAO,MAAM,iBAAiB,0LAqBmD,QAAQ,OAAO,CAAC,sBA6BhG,CAAC"}

package/out/hooks/useEntityProperty.js

@@ -37,6 +37,7 @@ const useEntityProperty = ({ entityManager, defaultRetryCount = 2 }) => {
                 }
             }
         }
+        return success;
     }, [entityManager]);
     const deleteProp = (0, react_1.useCallback)(async () => {
         await entityManager.delete();

package/out/hooks/useIssueProperty.d.ts

@@ -7,5 +7,5 @@
  *  2. A function to update the property value (with another value or an updater function). If a <retryCount> is given and an initial update fails, it automatically tries to update for another <retryCount> times (default 0).
  *  3. A function to delete the property.
  */
-export declare const useIssueProperty: <PropValue>(propertyKey: string, initValue: PropValue) => readonly [any, (valueUpdate: any, retryCount?: number) => Promise<void>, () => Promise<void>];
+export declare const useIssueProperty: <PropValue>(propertyKey: string, initValue: PropValue) => readonly [any, (valueUpdate: any, retryCount?: number) => Promise<boolean>, () => Promise<void>];
 //# sourceMappingURL=useIssueProperty.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useIssueProperty.d.ts","sourceRoot":"","sources":["../../src/hooks/useIssueProperty.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,2BAA4B,MAAM,wHAW9D,CAAC"}
+{"version":3,"file":"useIssueProperty.d.ts","sourceRoot":"","sources":["../../src/hooks/useIssueProperty.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,2BAA4B,MAAM,2HAW9D,CAAC"}

package/out/hooks/useSpaceProperty.d.ts

@@ -7,5 +7,5 @@
  *  2. A function to update the property value (with another value or an updater function). If an initial update fails, it automatically tries to update for another <retryCount> times (default 2).
  * 3. A function to delete the property.
  */
-export declare const useSpaceProperty: <PropValue>(propertyKey: string, initValue: PropValue) => readonly [PropValue | undefined, (valueUpdate: import("./types/entityProps").ValueUpdate<PropValue>, retryCount?: number) => Promise<void>, () => Promise<void>];
+export declare const useSpaceProperty: <PropValue>(propertyKey: string, initValue: PropValue) => readonly [PropValue | undefined, (valueUpdate: import("./types/entityProps").ValueUpdate<PropValue>, retryCount?: number) => Promise<boolean>, () => Promise<void>];
 //# sourceMappingURL=useSpaceProperty.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useSpaceProperty.d.ts","sourceRoot":"","sources":["../../src/hooks/useSpaceProperty.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,2BAA4B,MAAM,2LAW9D,CAAC"}
+{"version":3,"file":"useSpaceProperty.d.ts","sourceRoot":"","sources":["../../src/hooks/useSpaceProperty.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,2BAA4B,MAAM,8LAW9D,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forge/react",
-  "version": "11.3.0-next.1",
+  "version": "11.4.0-next.0",
   "description": "Forge React reconciler",
   "author": "Atlassian",
   "license": "SEE LICENSE IN LICENSE.txt",
@@ -28,7 +28,7 @@
     "@atlaskit/adf-schema": "^48.0.0",
     "@atlaskit/adf-utils": "^19.19.0",
     "@atlaskit/forge-react-types": "^0.42.10",
-    "@forge/bridge": "^5.5.0-next.0",
+    "@forge/bridge": "^5.5.0",
     "@forge/i18n": "0.0.7",
     "@types/react": "^18.2.64",
     "@types/react-reconciler": "^0.28.8",