@forge/react 11.6.1-next.1-experimental-f85d28a → 11.7.0-next.2

package/CHANGELOG.md

@@ -1,15 +1,15 @@
 # @forge/react
 
-## 11.6.1-next.1-experimental-f85d28a
+## 11.7.0-next.2
+
+### Minor Changes
+
+- f23a84e: Add useObjectStore hook
 
 ### Patch Changes
 
-- Updated dependencies [1d129f0]
-- Updated dependencies [fe20eb0]
-- Updated dependencies [08fbb0a]
-- Updated dependencies [617c3d9]
-- Updated dependencies [a4bccb7]
-  - @forge/bridge@5.8.0-next.12-experimental-f85d28a
+- Updated dependencies [f23a84e]
+  - @forge/bridge@5.8.0-next.13
 
 ## 11.6.1-next.1
 

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

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

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

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

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

@@ -0,0 +1,542 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const jsx_runtime_1 = require("react/jsx-runtime");
+// Mock data - define before imports
+const MOCK_FUNCTION_KEY = 'test-function-key';
+const MOCK_OBJECT_KEY_1 = 'object-key-1';
+const MOCK_OBJECT_KEY_2 = 'object-key-2';
+const MOCK_BLOB = new Blob(['test content'], { type: 'text/plain' });
+const MOCK_BASE64_OBJECT = { data: 'dGVzdCBjb250ZW50', mimeType: 'text/plain', fileSize: 12 };
+// Mock functions - define before imports
+const mockUpload = jest.fn();
+const mockCreateUploadPromises = jest.fn();
+const mockDelete = jest.fn();
+const mockDownload = jest.fn();
+const mockGetMetadata = jest.fn();
+const reconcilerTestRenderer_1 = tslib_1.__importDefault(require("../../__test__/reconcilerTestRenderer"));
+const testUtils_1 = require("../../__test__/testUtils");
+const useObjectStore_1 = require("../useObjectStore");
+// Mock @forge/bridge
+jest.mock('@forge/bridge', () => ({
+    objectStore: {
+        upload: mockUpload,
+        delete: mockDelete,
+        download: mockDownload,
+        getMetadata: mockGetMetadata
+    },
+    createUploadPromises: mockCreateUploadPromises
+}));
+describe('useObjectStore', () => {
+    beforeEach(() => {
+        // Clear all mocks before each test
+        jest.clearAllMocks();
+        (0, testUtils_1.setupBridge)(); // Set up global bridge for tests
+    });
+    describe('Initialization', () => {
+        it('should initialize with empty objectStates when no defaultValues provided', async () => {
+            let hookResult;
+            const TestComponent = () => {
+                hookResult = (0, useObjectStore_1.useObjectStore)();
+                return null;
+            };
+            await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+            expect(hookResult).toBeDefined();
+            if (!hookResult)
+                return;
+            expect(hookResult.objectStates).toEqual([]);
+        });
+        it('should initialize with defaultValues when provided', async () => {
+            const defaultValues = [
+                { key: MOCK_OBJECT_KEY_1, success: true, objectSize: 100 },
+                { key: MOCK_OBJECT_KEY_2, success: true, objectSize: 200 }
+            ];
+            let hookResult;
+            const TestComponent = () => {
+                hookResult = (0, useObjectStore_1.useObjectStore)({ defaultValues });
+                return null;
+            };
+            await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+            expect(hookResult).toBeDefined();
+            if (!hookResult)
+                return;
+            expect(hookResult.objectStates).toEqual(defaultValues);
+        });
+    });
+    describe('uploadObjects', () => {
+        it('should upload Blob objects successfully', async () => {
+            const mockResults = [{ key: MOCK_OBJECT_KEY_1, success: true, status: 200 }];
+            mockCreateUploadPromises.mockResolvedValueOnce([
+                { promise: Promise.resolve(mockResults[0]), index: 0, objectType: 'text/plain', objectSize: 12 }
+            ]);
+            let hookResult;
+            const TestComponent = () => {
+                hookResult = (0, useObjectStore_1.useObjectStore)();
+                return null;
+            };
+            await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+            expect(hookResult).toBeDefined();
+            if (!hookResult)
+                return;
+            // Before upload
+            expect(hookResult.objectStates).toEqual([]);
+            // Trigger upload
+            await hookResult.uploadObjects({
+                functionKey: MOCK_FUNCTION_KEY,
+                objects: [MOCK_BLOB]
+            });
+            // Should call bridge startUploads
+            expect(mockCreateUploadPromises).toHaveBeenCalledWith({
+                functionKey: MOCK_FUNCTION_KEY,
+                objects: [MOCK_BLOB]
+            });
+            // Should update state with results
+            expect(hookResult.objectStates).toHaveLength(1);
+            expect(hookResult.objectStates[0]).toMatchObject({
+                key: MOCK_OBJECT_KEY_1,
+                success: true,
+                status: 200,
+                objectType: 'text/plain',
+                objectSize: MOCK_BLOB.size
+            });
+        });
+        it('should upload Base64Object successfully with fileSize', async () => {
+            const mockResults = [{ key: MOCK_OBJECT_KEY_1, success: true, status: 200 }];
+            mockCreateUploadPromises.mockResolvedValueOnce([
+                { promise: Promise.resolve(mockResults[0]), index: 0, objectType: 'text/plain', objectSize: 12 }
+            ]);
+            let hookResult;
+            const TestComponent = () => {
+                hookResult = (0, useObjectStore_1.useObjectStore)();
+                return null;
+            };
+            await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+            expect(hookResult).toBeDefined();
+            if (!hookResult)
+                return;
+            await hookResult.uploadObjects({
+                functionKey: MOCK_FUNCTION_KEY,
+                objects: [MOCK_BASE64_OBJECT]
+            });
+            expect(hookResult.objectStates[0]).toMatchObject({
+                key: MOCK_OBJECT_KEY_1,
+                success: true,
+                objectType: 'text/plain',
+                objectSize: 12 // Uses provided fileSize
+            });
+        });
+        it('should calculate objectSize from base64 data when fileSize not provided', async () => {
+            const base64WithoutSize = { data: 'dGVzdA==', mimeType: 'text/plain' };
+            const mockResults = [{ key: MOCK_OBJECT_KEY_1, success: true, status: 200 }];
+            mockCreateUploadPromises.mockResolvedValueOnce([
+                { promise: Promise.resolve(mockResults[0]), index: 0, objectType: 'text/plain', objectSize: 4 }
+            ]);
+            let hookResult;
+            const TestComponent = () => {
+                hookResult = (0, useObjectStore_1.useObjectStore)();
+                return null;
+            };
+            await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+            expect(hookResult).toBeDefined();
+            if (!hookResult)
+                return;
+            await hookResult.uploadObjects({
+                functionKey: MOCK_FUNCTION_KEY,
+                objects: [base64WithoutSize]
+            });
+            // Should calculate size from base64: (8 * 3 / 4) - 2 = 4
+            expect(hookResult.objectStates[0].objectSize).toBe(4);
+        });
+        it('should show isUploading state during upload', async () => {
+            let resolveUpload;
+            const uploadPromise = new Promise((resolve) => {
+                resolveUpload = resolve;
+            });
+            mockCreateUploadPromises.mockResolvedValueOnce([
+                { promise: uploadPromise, index: 0, objectType: 'text/plain', objectSize: 12 }
+            ]);
+            let hookResult;
+            const TestComponent = () => {
+                hookResult = (0, useObjectStore_1.useObjectStore)();
+                return null;
+            };
+            await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+            expect(hookResult).toBeDefined();
+            if (!hookResult)
+                return;
+            // Start upload (don't await)
+            const uploadPromiseResult = hookResult.uploadObjects({
+                functionKey: MOCK_FUNCTION_KEY,
+                objects: [MOCK_BLOB]
+            });
+            // Give a tick for state to update
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            // Should have temp object with isUploading: true
+            expect(hookResult.objectStates).toHaveLength(1);
+            expect(hookResult.objectStates[0].isUploading).toBe(true);
+            expect(hookResult.objectStates[0].key).toMatch(/^temp-upload-/);
+            // Resolve upload
+            resolveUpload({ key: MOCK_OBJECT_KEY_1, success: true, status: 200 });
+            await uploadPromiseResult;
+            // Temp object should be replaced with real object (no isUploading)
+            expect(hookResult.objectStates).toHaveLength(1);
+            expect(hookResult.objectStates[0].key).toBe(MOCK_OBJECT_KEY_1);
+            expect(hookResult.objectStates[0].isUploading).toBeUndefined();
+        });
+        it('should handle upload errors and remove temp objects', async () => {
+            const uploadError = new Error('Upload failed');
+            mockCreateUploadPromises.mockRejectedValueOnce(uploadError);
+            let hookResult;
+            const TestComponent = () => {
+                hookResult = (0, useObjectStore_1.useObjectStore)();
+                return null;
+            };
+            await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+            expect(hookResult).toBeDefined();
+            if (!hookResult)
+                return;
+            await expect(hookResult.uploadObjects({
+                functionKey: MOCK_FUNCTION_KEY,
+                objects: [MOCK_BLOB]
+            })).rejects.toThrow('Upload failed');
+            // Temp objects should be removed
+            expect(hookResult.objectStates).toEqual([]);
+        });
+        it('should upload multiple objects', async () => {
+            const mockResults = [
+                { key: MOCK_OBJECT_KEY_1, success: true, status: 200 },
+                { key: MOCK_OBJECT_KEY_2, success: true, status: 200 }
+            ];
+            mockCreateUploadPromises.mockResolvedValueOnce([
+                { promise: Promise.resolve(mockResults[0]), index: 0, objectType: 'text/plain', objectSize: 12 },
+                { promise: Promise.resolve(mockResults[1]), index: 1, objectType: 'text/plain', objectSize: 12 }
+            ]);
+            let hookResult;
+            const TestComponent = () => {
+                hookResult = (0, useObjectStore_1.useObjectStore)();
+                return null;
+            };
+            await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+            expect(hookResult).toBeDefined();
+            if (!hookResult)
+                return;
+            const blob1 = new Blob(['test1'], { type: 'text/plain' });
+            const blob2 = new Blob(['test2'], { type: 'text/plain' });
+            await hookResult.uploadObjects({
+                functionKey: MOCK_FUNCTION_KEY,
+                objects: [blob1, blob2]
+            });
+            expect(hookResult.objectStates).toHaveLength(2);
+            expect(hookResult.objectStates[0].key).toBe(MOCK_OBJECT_KEY_1);
+            expect(hookResult.objectStates[1].key).toBe(MOCK_OBJECT_KEY_2);
+        });
+    });
+    describe('deleteObject', () => {
+        it('should delete object successfully', async () => {
+            mockDelete.mockResolvedValueOnce(undefined);
+            const defaultValues = [{ key: MOCK_OBJECT_KEY_1, success: true, objectSize: 100 }];
+            let hookResult;
+            const TestComponent = () => {
+                hookResult = (0, useObjectStore_1.useObjectStore)({ defaultValues });
+                return null;
+            };
+            await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+            expect(hookResult).toBeDefined();
+            if (!hookResult)
+                return;
+            // Before delete
+            expect(hookResult.objectStates).toHaveLength(1);
+            // Delete object
+            await hookResult.deleteObjects({ functionKey: MOCK_FUNCTION_KEY, keys: [MOCK_OBJECT_KEY_1] });
+            // Should call bridge delete
+            expect(mockDelete).toHaveBeenCalledWith({
+                functionKey: MOCK_FUNCTION_KEY,
+                keys: [MOCK_OBJECT_KEY_1]
+            });
+            // Object should be removed from state
+            expect(hookResult.objectStates).toEqual([]);
+        });
+        it('should show isDeleting state during delete', async () => {
+            let resolveDelete;
+            const deletePromise = new Promise((resolve) => {
+                resolveDelete = resolve;
+            });
+            mockDelete.mockReturnValueOnce(deletePromise);
+            const defaultValues = [{ key: MOCK_OBJECT_KEY_1, success: true, objectSize: 100 }];
+            let hookResult;
+            const TestComponent = () => {
+                hookResult = (0, useObjectStore_1.useObjectStore)({ defaultValues });
+                return null;
+            };
+            await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+            expect(hookResult).toBeDefined();
+            if (!hookResult)
+                return;
+            // Start delete (don't await)
+            const deletePromiseResult = hookResult.deleteObjects({
+                functionKey: MOCK_FUNCTION_KEY,
+                keys: [MOCK_OBJECT_KEY_1]
+            });
+            // Give a tick for state to update
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            // Should have isDeleting: true
+            expect(hookResult.objectStates[0].isDeleting).toBe(true);
+            // Resolve delete
+            resolveDelete(undefined);
+            await deletePromiseResult;
+            // Object should be removed
+            expect(hookResult.objectStates).toEqual([]);
+        });
+        it('should handle delete errors and set error state', async () => {
+            const deleteError = new Error('Delete failed');
+            mockDelete.mockRejectedValueOnce(deleteError);
+            const defaultValues = [{ key: MOCK_OBJECT_KEY_1, success: true, objectSize: 100 }];
+            let hookResult;
+            const TestComponent = () => {
+                hookResult = (0, useObjectStore_1.useObjectStore)({ defaultValues });
+                return null;
+            };
+            await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+            expect(hookResult).toBeDefined();
+            if (!hookResult)
+                return;
+            await expect(hookResult.deleteObjects({ functionKey: MOCK_FUNCTION_KEY, keys: [MOCK_OBJECT_KEY_1] })).rejects.toThrow('Delete failed');
+            // Object should still exist with error state
+            expect(hookResult.objectStates).toHaveLength(1);
+            expect(hookResult.objectStates[0].isDeleting).toBe(false);
+            expect(hookResult.objectStates[0].error).toBe('Delete failed');
+        });
+        it('should delete multiple objects successfully', async () => {
+            mockDelete.mockResolvedValueOnce(undefined);
+            const defaultValues = [
+                { key: MOCK_OBJECT_KEY_1, success: true, objectSize: 100 },
+                { key: MOCK_OBJECT_KEY_2, success: true, objectSize: 200 }
+            ];
+            let hookResult;
+            const TestComponent = () => {
+                hookResult = (0, useObjectStore_1.useObjectStore)({ defaultValues });
+                return null;
+            };
+            await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+            expect(hookResult).toBeDefined();
+            if (!hookResult)
+                return;
+            // Before delete
+            expect(hookResult.objectStates).toHaveLength(2);
+            // Delete both objects
+            await hookResult.deleteObjects({
+                functionKey: MOCK_FUNCTION_KEY,
+                keys: [MOCK_OBJECT_KEY_1, MOCK_OBJECT_KEY_2]
+            });
+            // Should call bridge delete with both keys
+            expect(mockDelete).toHaveBeenCalledWith({
+                functionKey: MOCK_FUNCTION_KEY,
+                keys: [MOCK_OBJECT_KEY_1, MOCK_OBJECT_KEY_2]
+            });
+            // Both objects should be removed from state
+            expect(hookResult.objectStates).toEqual([]);
+        });
+        it('should show isDeleting state for multiple objects during delete', async () => {
+            let resolveDelete;
+            const deletePromise = new Promise((resolve) => {
+                resolveDelete = resolve;
+            });
+            mockDelete.mockReturnValueOnce(deletePromise);
+            const defaultValues = [
+                { key: MOCK_OBJECT_KEY_1, success: true, objectSize: 100 },
+                { key: MOCK_OBJECT_KEY_2, success: true, objectSize: 200 }
+            ];
+            let hookResult;
+            const TestComponent = () => {
+                hookResult = (0, useObjectStore_1.useObjectStore)({ defaultValues });
+                return null;
+            };
+            await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+            expect(hookResult).toBeDefined();
+            if (!hookResult)
+                return;
+            // Start delete (don't await)
+            const deletePromiseResult = hookResult.deleteObjects({
+                functionKey: MOCK_FUNCTION_KEY,
+                keys: [MOCK_OBJECT_KEY_1, MOCK_OBJECT_KEY_2]
+            });
+            // Give a tick for state to update
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            // Both should have isDeleting: true
+            expect(hookResult.objectStates[0].isDeleting).toBe(true);
+            expect(hookResult.objectStates[1].isDeleting).toBe(true);
+            // Resolve delete
+            resolveDelete(undefined);
+            await deletePromiseResult;
+            // Both objects should be removed
+            expect(hookResult.objectStates).toEqual([]);
+        });
+    });
+    describe('downloadObjects', () => {
+        it('should download object successfully', async () => {
+            const mockBlob = new Blob(['downloaded content']);
+            const mockResults = [{ success: true, key: MOCK_OBJECT_KEY_1, blob: mockBlob }];
+            mockDownload.mockResolvedValueOnce(mockResults);
+            const defaultValues = [{ key: MOCK_OBJECT_KEY_1, success: true, objectSize: 100 }];
+            let hookResult;
+            const TestComponent = () => {
+                hookResult = (0, useObjectStore_1.useObjectStore)({ defaultValues });
+                return null;
+            };
+            await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+            expect(hookResult).toBeDefined();
+            if (!hookResult)
+                return;
+            const result = await hookResult.downloadObjects({ functionKey: MOCK_FUNCTION_KEY, keys: [MOCK_OBJECT_KEY_1] });
+            // Should call bridge download
+            expect(mockDownload).toHaveBeenCalledWith({
+                functionKey: MOCK_FUNCTION_KEY,
+                keys: [MOCK_OBJECT_KEY_1]
+            });
+            // Should return results with blob
+            expect(result[0].blob).toBe(mockBlob);
+        });
+        it('should show isDownloading state during download', async () => {
+            let resolveDownload;
+            const downloadPromise = new Promise((resolve) => {
+                resolveDownload = resolve;
+            });
+            mockDownload.mockReturnValueOnce(downloadPromise);
+            const defaultValues = [{ key: MOCK_OBJECT_KEY_1, success: true, objectSize: 100 }];
+            let hookResult;
+            const TestComponent = () => {
+                hookResult = (0, useObjectStore_1.useObjectStore)({ defaultValues });
+                return null;
+            };
+            await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+            expect(hookResult).toBeDefined();
+            if (!hookResult)
+                return;
+            // Start download (don't await)
+            const downloadPromiseResult = hookResult.downloadObjects({
+                functionKey: MOCK_FUNCTION_KEY,
+                keys: [MOCK_OBJECT_KEY_1]
+            });
+            // Give a tick for state to update
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            // Should have isDownloading: true
+            expect(hookResult.objectStates[0].isDownloading).toBe(true);
+            // Resolve download
+            const mockBlob = new Blob(['content']);
+            resolveDownload([{ success: true, key: MOCK_OBJECT_KEY_1, blob: mockBlob }]);
+            await downloadPromiseResult;
+            // isDownloading should be false
+            expect(hookResult.objectStates[0].isDownloading).toBe(false);
+        });
+        it('should handle download errors and set error state', async () => {
+            const downloadError = new Error('Download failed');
+            mockDownload.mockRejectedValueOnce(downloadError);
+            const defaultValues = [{ key: MOCK_OBJECT_KEY_1, success: true, objectSize: 100 }];
+            let hookResult;
+            const TestComponent = () => {
+                hookResult = (0, useObjectStore_1.useObjectStore)({ defaultValues });
+                return null;
+            };
+            await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+            expect(hookResult).toBeDefined();
+            if (!hookResult)
+                return;
+            await expect(hookResult.downloadObjects({ functionKey: MOCK_FUNCTION_KEY, keys: [MOCK_OBJECT_KEY_1] })).rejects.toThrow('Download failed');
+            // Object should have error state
+            expect(hookResult.objectStates[0].isDownloading).toBe(false);
+            expect(hookResult.objectStates[0].error).toBe('Download failed');
+        });
+        it('should return null when download result has no blob', async () => {
+            const mockResults = [{ success: false, key: MOCK_OBJECT_KEY_1, error: 'Not found' }];
+            mockDownload.mockResolvedValueOnce(mockResults);
+            const defaultValues = [{ key: MOCK_OBJECT_KEY_1, success: true, objectSize: 100 }];
+            let hookResult;
+            const TestComponent = () => {
+                hookResult = (0, useObjectStore_1.useObjectStore)({ defaultValues });
+                return null;
+            };
+            await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+            expect(hookResult).toBeDefined();
+            if (!hookResult)
+                return;
+            const result = await hookResult.downloadObjects({
+                functionKey: MOCK_FUNCTION_KEY,
+                keys: [MOCK_OBJECT_KEY_1]
+            });
+            expect(result[0].success).toBe(false);
+            expect(result[0].blob).toBeUndefined();
+            expect(hookResult.objectStates[0].error).toBe('Download failed');
+        });
+    });
+    describe('getObjectMetadata', () => {
+        it('should return object from state when it exists', async () => {
+            const defaultValues = [{ key: MOCK_OBJECT_KEY_1, success: true, objectSize: 100 }];
+            let hookResult;
+            const TestComponent = () => {
+                hookResult = (0, useObjectStore_1.useObjectStore)({ defaultValues });
+                return null;
+            };
+            await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+            expect(hookResult).toBeDefined();
+            if (!hookResult)
+                return;
+            const result = hookResult.getObjectMetadata(MOCK_OBJECT_KEY_1);
+            expect(result).toEqual(defaultValues[0]);
+        });
+        it('should return null when object not in state', async () => {
+            let hookResult;
+            const TestComponent = () => {
+                hookResult = (0, useObjectStore_1.useObjectStore)();
+                return null;
+            };
+            await reconcilerTestRenderer_1.default.create((0, jsx_runtime_1.jsx)(TestComponent, {}));
+            expect(hookResult).toBeDefined();
+            if (!hookResult)
+                return;
+            const result = hookResult.getObjectMetadata(MOCK_OBJECT_KEY_1);
+            expect(result).toBeNull();
+        });
+    });
+    describe('Function memoization', () => {
+        it('should preserve uploadObjects function reference between renders', async () => {
+            let uploadFunction1;
+            let uploadFunction2;
+            const TestComponent = ({ renderKey }) => {
+                const { uploadObjects } = (0, useObjectStore_1.useObjectStore)();
+                if (renderKey === 1)
+                    uploadFunction1 = uploadObjects;
+                if (renderKey === 2)
+                    uploadFunction2 = uploadObjects;
+                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(uploadFunction1).toBeDefined();
+            expect(uploadFunction2).toBeDefined();
+            expect(typeof uploadFunction1).toBe('function');
+            expect(typeof uploadFunction2).toBe('function');
+            // Note: Function reference stability depends on test renderer behavior
+        });
+        it('should preserve deleteObjects function reference between renders', async () => {
+            let deleteFunction1;
+            let deleteFunction2;
+            const TestComponent = ({ renderKey }) => {
+                const { deleteObjects } = (0, useObjectStore_1.useObjectStore)();
+                if (renderKey === 1)
+                    deleteFunction1 = deleteObjects;
+                if (renderKey === 2)
+                    deleteFunction2 = deleteObjects;
+                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(deleteFunction1).toBeDefined();
+            expect(deleteFunction2).toBeDefined();
+            expect(typeof deleteFunction1).toBe('function');
+            expect(typeof deleteFunction2).toBe('function');
+            // Note: Function reference stability depends on test renderer behavior
+        });
+    });
+});

package/out/hooks/types/objectStoreProps.d.ts

@@ -0,0 +1,33 @@
+import type { UploadObject, UploadResult, Base64Object } from '@forge/bridge';
+export type { UploadObject, UploadResult, Base64Object };
+export declare type ObjectState = {
+    key: string;
+    success?: boolean;
+    status?: number;
+    error?: string;
+    objectType?: string;
+    objectSize?: number;
+    isUploading?: boolean;
+    isDeleting?: boolean;
+    isDownloading?: boolean;
+};
+export declare type UseObjectStoreProps = {
+    defaultValues?: ObjectState[];
+};
+export declare type UploadParams = {
+    functionKey: string;
+    objects: UploadObject[];
+};
+export declare type DeleteParams = {
+    functionKey: string;
+    keys: string[];
+};
+export declare type DownloadParams = {
+    functionKey: string;
+    keys: string[];
+};
+export declare type ClearAllObjectsOptions = {
+    deleteFromStore?: boolean;
+    functionKey?: string;
+};
+//# sourceMappingURL=objectStoreProps.d.ts.map

package/out/hooks/types/objectStoreProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objectStoreProps.d.ts","sourceRoot":"","sources":["../../../src/hooks/types/objectStoreProps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE9E,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC;AAEzD,oBAAY,WAAW,GAAG;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,oBAAY,mBAAmB,GAAG;IAChC,aAAa,CAAC,EAAE,WAAW,EAAE,CAAC;CAC/B,CAAC;AAEF,oBAAY,YAAY,GAAG;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,YAAY,EAAE,CAAC;CACzB,CAAC;AAEF,oBAAY,YAAY,GAAG;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAEF,oBAAY,cAAc,GAAG;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAEF,oBAAY,sBAAsB,GAAG;IACnC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC"}

package/out/hooks/types/objectStoreProps.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/out/hooks/useObjectStore.d.ts

@@ -0,0 +1,9 @@
+import type { ObjectState, UseObjectStoreProps, UploadParams, DeleteParams, DownloadParams } from './types/objectStoreProps';
+export declare function useObjectStore(props?: UseObjectStoreProps): {
+    objectStates: ObjectState[];
+    getObjectMetadata: (key: string) => ObjectState | null;
+    uploadObjects: (params: UploadParams) => Promise<void>;
+    deleteObjects: (params: DeleteParams) => Promise<void>;
+    downloadObjects: (params: DownloadParams) => Promise<import("@forge/bridge").DownloadResult[]>;
+};
+//# sourceMappingURL=useObjectStore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useObjectStore.d.ts","sourceRoot":"","sources":["../../src/hooks/useObjectStore.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,WAAW,EACX,mBAAmB,EACnB,YAAY,EACZ,YAAY,EACZ,cAAc,EACf,MAAM,0BAA0B,CAAC;AAqFlC,wBAAgB,cAAc,CAAC,KAAK,GAAE,mBAAwB;;6BAQ5B,MAAM,KAAG,WAAW,GAAG,IAAI;4BAeV,YAAY,KAAG,QAAQ,IAAI,CAAC;4BA2C5B,YAAY,KAAG,QAAQ,IAAI,CAAC;8BAkB1B,cAAc;EA+BlE"}