@oneblink/apps-react 2.3.0-beta.1 → 2.3.0-beta.2

package/dist/hooks/attachments/useAttachment.js

@@ -1,243 +1,243 @@
-import * as React from 'react';
-import { submissionService } from '@oneblink/apps';
-import useFormDefinition from '../useFormDefinition';
-import useIsOffline from '../useIsOffline';
-import { checkIfContentTypeIsImage } from '../../services/attachments';
-import useAuth from '../../hooks/useAuth';
-import { urlToBlobAsync } from '../../services/blob-utils';
-import useAttachmentBlobs from '../../hooks/attachments/useAttachmentBlobs';
-export default function useAttachment(value, element, onChange, disableUpload) {
-    const isPrivate = element.storageType !== 'public';
-    const form = useFormDefinition();
-    const isOffline = useIsOffline();
-    const { isLoggedIn, isUsingFormsKey } = useAuth();
-    const { storeAttachmentBlobLocally, getAttachmentBlobLocally } = useAttachmentBlobs();
-    const isAuthenticated = isLoggedIn || isUsingFormsKey;
-    const [imageUrlState, setImageUrlState] = React.useState({});
-    const [progressState, setProgressState] = React.useState();
-    const onProgress = React.useCallback(({ progress }) => {
-        setProgressState(progress);
-    }, []);
-    // TRIGGER UPLOAD
-    React.useEffect(() => {
-        const formId = form === null || form === void 0 ? void 0 : form.id;
-        if (isOffline ||
-            disableUpload ||
-            !formId ||
-            !value ||
-            typeof value !== 'object' ||
-            value.type !== 'NEW' ||
-            !value.data) {
-            return;
-        }
-        const newAttachment = value;
-        const data = value.data;
-        let ignore = false;
-        const abortController = new AbortController();
-        const effect = async () => {
-            try {
-                console.log('Attempting to upload attachment...', newAttachment.fileName);
-                const upload = await submissionService.uploadAttachment({
-                    formId,
-                    fileName: newAttachment.fileName,
-                    contentType: data.type,
-                    data,
-                    isPrivate,
-                    onProgress,
-                }, abortController.signal);
-                if (ignore) {
-                    return;
-                }
-                // Store Blob in Context if image is private
-                if (isPrivate) {
-                    storeAttachmentBlobLocally({ attachmentId: upload.id, blob: data });
-                }
-                console.log('Successfully Uploaded attachment!', upload);
-                // UPDATE ATTACHMENT
-                onChange(newAttachment._id, upload);
-            }
-            catch (error) {
-                if (ignore) {
-                    return;
-                }
-                console.warn('Failed to upload attachment...', newAttachment.fileName, error);
-                onChange(newAttachment._id, {
-                    ...newAttachment,
-                    type: 'ERROR',
-                    errorMessage: error.message,
-                });
-            }
-        };
-        effect();
-        return () => {
-            ignore = true;
-            abortController.abort();
-        };
-    }, [
-        disableUpload,
-        form === null || form === void 0 ? void 0 : form.id,
-        isOffline,
-        isPrivate,
-        onChange,
-        onProgress,
-        storeAttachmentBlobLocally,
-        value,
-    ]);
-    // TRIGGER DOWNLOAD
-    React.useEffect(() => {
-        if (!value) {
-            return;
-        }
-        // If the value is string we will assume a base64 data uri
-        if (typeof value === 'string') {
-            setImageUrlState({
-                imageUrl: value,
-            });
-            return;
-        }
-        if (value.type) {
-            if (!value.data) {
-                return;
-            }
-            if (!checkIfContentTypeIsImage(value.data.type)) {
-                // Not an image which we will represent as null
-                setImageUrlState({
-                    imageUrl: null,
-                });
-                return;
-            }
-            const imageUrl = URL.createObjectURL(value.data);
-            console.log('Created object url from blob for image', imageUrl);
-            setImageUrlState({
-                imageUrl,
-            });
-            return;
-        }
-        if (!checkIfContentTypeIsImage(value.contentType)) {
-            // Not an image which we will represent as null
-            setImageUrlState({
-                imageUrl: null,
-            });
-            return;
-        }
-        // If the file is a public url we can finish here and just use that
-        if (!value.isPrivate) {
-            setImageUrlState({
-                imageUrl: value.url,
-            });
-            return;
-        }
-        // Check for locally stored Blob. Blob should be stored locally for private uploaded images only
-        const locallyStoredAttachment = getAttachmentBlobLocally(value.id);
-        if (locallyStoredAttachment) {
-            const imageUrl = URL.createObjectURL(locallyStoredAttachment.blob);
-            console.log('Created object url from locally stored Blob for private image attachment', imageUrl);
-            setImageUrlState({
-                imageUrl,
-            });
-            return;
-        }
-        // If user is not logged in or is offline, we can't download private images.
-        // If the blob was not stored locally (above) for some reason, the user is SOL
-        if (!isAuthenticated || isOffline) {
-            setImageUrlState({
-                imageUrl: null,
-            });
-            return;
-        }
-        let ignore = false;
-        const abortController = new AbortController();
-        const privateImageUrl = value.url;
-        const effect = async () => {
-            try {
-                const blob = await urlToBlobAsync(privateImageUrl, true, abortController.signal);
-                if (ignore) {
-                    return;
-                }
-                // Store private image attachment in Context
-                storeAttachmentBlobLocally({ attachmentId: value.id, blob });
-                const imageUrl = URL.createObjectURL(blob);
-                console.log('Created object url from private attachment for image', imageUrl);
-                setImageUrlState({
-                    imageUrl,
-                });
-            }
-            catch (error) {
-                if (ignore) {
-                    return;
-                }
-                console.warn('Error loading file:', error);
-                setImageUrlState({
-                    loadImageUrlError: error,
-                });
-            }
-        };
-        effect();
-        return () => {
-            ignore = true;
-            abortController.abort();
-        };
-    }, [
-        getAttachmentBlobLocally,
-        isAuthenticated,
-        isOffline,
-        storeAttachmentBlobLocally,
-        value,
-    ]);
-    React.useEffect(() => {
-        return () => {
-            const imageUrl = imageUrlState.imageUrl;
-            if (imageUrl && imageUrl.startsWith('blob:')) {
-                console.log('revoking image url:', imageUrl);
-                URL.revokeObjectURL(imageUrl);
-            }
-        };
-    }, [imageUrlState.imageUrl]);
-    const isUploading = React.useMemo(() => {
-        return !!(value &&
-            typeof value !== 'string' &&
-            value.type &&
-            value.type === 'NEW');
-    }, [value]);
-    const uploadErrorMessage = React.useMemo(() => {
-        if (value &&
-            typeof value !== 'string' &&
-            value.type &&
-            value.type === 'ERROR') {
-            return value.errorMessage;
-        }
-    }, [value]);
-    const canDownload = React.useMemo(() => {
-        if (!value) {
-            return false;
-        }
-        // legacy attachment as base64 data
-        if (typeof value === 'string') {
-            return true;
-        }
-        // attachments still uploading or failed to upload
-        if (value.type) {
-            // can only be downloaded if we still have the data
-            return !!value.data;
-        }
-        // attachments that have been uploaded
-        // public attachments can always be downloaded
-        if (!value.isPrivate) {
-            return true;
-        }
-        // private attachments can only be downloaded if user is authenticated
-        if (isAuthenticated) {
-            return true;
-        }
-        return false;
-    }, [isAuthenticated, value]);
-    return {
-        isUploading,
-        uploadErrorMessage,
-        isLoadingImageUrl: imageUrlState.imageUrl === undefined,
-        ...imageUrlState,
-        canDownload,
-        progress: progressState,
-    };
-}
+import * as React from 'react';
+import { submissionService } from '@oneblink/apps';
+import useFormDefinition from '../useFormDefinition';
+import useIsOffline from '../useIsOffline';
+import { checkIfContentTypeIsImage } from '../../services/attachments';
+import useAuth from '../../hooks/useAuth';
+import { urlToBlobAsync } from '../../services/blob-utils';
+import useAttachmentBlobs from '../../hooks/attachments/useAttachmentBlobs';
+export default function useAttachment(value, element, onChange, disableUpload) {
+    const isPrivate = element.storageType !== 'public';
+    const form = useFormDefinition();
+    const isOffline = useIsOffline();
+    const { isLoggedIn, isUsingFormsKey } = useAuth();
+    const { storeAttachmentBlobLocally, getAttachmentBlobLocally } = useAttachmentBlobs();
+    const isAuthenticated = isLoggedIn || isUsingFormsKey;
+    const [imageUrlState, setImageUrlState] = React.useState({});
+    const [progressState, setProgressState] = React.useState();
+    const onProgress = React.useCallback(({ progress }) => {
+        setProgressState(progress);
+    }, []);
+    // TRIGGER UPLOAD
+    React.useEffect(() => {
+        const formId = form === null || form === void 0 ? void 0 : form.id;
+        if (isOffline ||
+            disableUpload ||
+            !formId ||
+            !value ||
+            typeof value !== 'object' ||
+            value.type !== 'NEW' ||
+            !value.data) {
+            return;
+        }
+        const newAttachment = value;
+        const data = value.data;
+        let ignore = false;
+        const abortController = new AbortController();
+        const effect = async () => {
+            try {
+                console.log('Attempting to upload attachment...', newAttachment.fileName);
+                const upload = await submissionService.uploadAttachment({
+                    formId,
+                    fileName: newAttachment.fileName,
+                    contentType: data.type,
+                    data,
+                    isPrivate,
+                    onProgress,
+                }, abortController.signal);
+                if (ignore) {
+                    return;
+                }
+                // Store Blob in Context if image is private
+                if (isPrivate) {
+                    storeAttachmentBlobLocally({ attachmentId: upload.id, blob: data });
+                }
+                console.log('Successfully Uploaded attachment!', upload);
+                // UPDATE ATTACHMENT
+                onChange(newAttachment._id, upload);
+            }
+            catch (error) {
+                if (ignore) {
+                    return;
+                }
+                console.warn('Failed to upload attachment...', newAttachment.fileName, error);
+                onChange(newAttachment._id, {
+                    ...newAttachment,
+                    type: 'ERROR',
+                    errorMessage: error.message,
+                });
+            }
+        };
+        effect();
+        return () => {
+            ignore = true;
+            abortController.abort();
+        };
+    }, [
+        disableUpload,
+        form === null || form === void 0 ? void 0 : form.id,
+        isOffline,
+        isPrivate,
+        onChange,
+        onProgress,
+        storeAttachmentBlobLocally,
+        value,
+    ]);
+    // TRIGGER DOWNLOAD
+    React.useEffect(() => {
+        if (!value) {
+            return;
+        }
+        // If the value is string we will assume a base64 data uri
+        if (typeof value === 'string') {
+            setImageUrlState({
+                imageUrl: value,
+            });
+            return;
+        }
+        if (value.type) {
+            if (!value.data) {
+                return;
+            }
+            if (!checkIfContentTypeIsImage(value.data.type)) {
+                // Not an image which we will represent as null
+                setImageUrlState({
+                    imageUrl: null,
+                });
+                return;
+            }
+            const imageUrl = URL.createObjectURL(value.data);
+            console.log('Created object url from blob for image', imageUrl);
+            setImageUrlState({
+                imageUrl,
+            });
+            return;
+        }
+        if (!checkIfContentTypeIsImage(value.contentType)) {
+            // Not an image which we will represent as null
+            setImageUrlState({
+                imageUrl: null,
+            });
+            return;
+        }
+        // If the file is a public url we can finish here and just use that
+        if (!value.isPrivate) {
+            setImageUrlState({
+                imageUrl: value.url,
+            });
+            return;
+        }
+        // Check for locally stored Blob. Blob should be stored locally for private uploaded images only
+        const locallyStoredAttachment = getAttachmentBlobLocally(value.id);
+        if (locallyStoredAttachment) {
+            const imageUrl = URL.createObjectURL(locallyStoredAttachment.blob);
+            console.log('Created object url from locally stored Blob for private image attachment', imageUrl);
+            setImageUrlState({
+                imageUrl,
+            });
+            return;
+        }
+        // If user is not logged in or is offline, we can't download private images.
+        // If the blob was not stored locally (above) for some reason, the user is SOL
+        if (!isAuthenticated || isOffline) {
+            setImageUrlState({
+                imageUrl: null,
+            });
+            return;
+        }
+        let ignore = false;
+        const abortController = new AbortController();
+        const privateImageUrl = value.url;
+        const effect = async () => {
+            try {
+                const blob = await urlToBlobAsync(privateImageUrl, true, abortController.signal);
+                if (ignore) {
+                    return;
+                }
+                // Store private image attachment in Context
+                storeAttachmentBlobLocally({ attachmentId: value.id, blob });
+                const imageUrl = URL.createObjectURL(blob);
+                console.log('Created object url from private attachment for image', imageUrl);
+                setImageUrlState({
+                    imageUrl,
+                });
+            }
+            catch (error) {
+                if (ignore) {
+                    return;
+                }
+                console.warn('Error loading file:', error);
+                setImageUrlState({
+                    loadImageUrlError: error,
+                });
+            }
+        };
+        effect();
+        return () => {
+            ignore = true;
+            abortController.abort();
+        };
+    }, [
+        getAttachmentBlobLocally,
+        isAuthenticated,
+        isOffline,
+        storeAttachmentBlobLocally,
+        value,
+    ]);
+    React.useEffect(() => {
+        return () => {
+            const imageUrl = imageUrlState.imageUrl;
+            if (imageUrl && imageUrl.startsWith('blob:')) {
+                console.log('revoking image url:', imageUrl);
+                URL.revokeObjectURL(imageUrl);
+            }
+        };
+    }, [imageUrlState.imageUrl]);
+    const isUploading = React.useMemo(() => {
+        return !!(value &&
+            typeof value !== 'string' &&
+            value.type &&
+            value.type === 'NEW');
+    }, [value]);
+    const uploadErrorMessage = React.useMemo(() => {
+        if (value &&
+            typeof value !== 'string' &&
+            value.type &&
+            value.type === 'ERROR') {
+            return value.errorMessage;
+        }
+    }, [value]);
+    const canDownload = React.useMemo(() => {
+        if (!value) {
+            return false;
+        }
+        // legacy attachment as base64 data
+        if (typeof value === 'string') {
+            return true;
+        }
+        // attachments still uploading or failed to upload
+        if (value.type) {
+            // can only be downloaded if we still have the data
+            return !!value.data;
+        }
+        // attachments that have been uploaded
+        // public attachments can always be downloaded
+        if (!value.isPrivate) {
+            return true;
+        }
+        // private attachments can only be downloaded if user is authenticated
+        if (isAuthenticated) {
+            return true;
+        }
+        return false;
+    }, [isAuthenticated, value]);
+    return {
+        isUploading,
+        uploadErrorMessage,
+        isLoadingImageUrl: imageUrlState.imageUrl === undefined,
+        ...imageUrlState,
+        canDownload,
+        progress: progressState,
+    };
+}
 //# sourceMappingURL=useAttachment.js.map

package/dist/hooks/attachments/useAttachmentBlobs.d.ts

@@ -1,19 +1,19 @@
-import * as React from 'react';
-declare type AttachmentObjectBlob = {
-    attachmentId: string;
-    blob: Blob;
-};
-declare type RegisterAttachmentParam = {
-    blob: Blob;
-    attachmentId: string;
-};
-declare type AttachmentBlobsContextValue = {
-    storeAttachmentBlobLocally: (options: RegisterAttachmentParam) => void;
-    getAttachmentBlobLocally: (attachmentId: string) => AttachmentObjectBlob | undefined;
-};
-declare type Props = {
-    children: React.ReactNode;
-};
-export declare const AttachmentBlobsProvider: ({ children }: Props) => JSX.Element;
-declare const useAttachmentBlobs: () => AttachmentBlobsContextValue;
-export default useAttachmentBlobs;
+import * as React from 'react';
+declare type AttachmentObjectBlob = {
+    attachmentId: string;
+    blob: Blob;
+};
+declare type RegisterAttachmentParam = {
+    blob: Blob;
+    attachmentId: string;
+};
+declare type AttachmentBlobsContextValue = {
+    storeAttachmentBlobLocally: (options: RegisterAttachmentParam) => void;
+    getAttachmentBlobLocally: (attachmentId: string) => AttachmentObjectBlob | undefined;
+};
+declare type Props = {
+    children: React.ReactNode;
+};
+export declare const AttachmentBlobsProvider: ({ children }: Props) => JSX.Element;
+declare const useAttachmentBlobs: () => AttachmentBlobsContextValue;
+export default useAttachmentBlobs;

package/dist/hooks/attachments/useAttachmentBlobs.js

@@ -1,24 +1,24 @@
-import * as React from 'react';
-const AttachmentBlobsContext = React.createContext({
-    storeAttachmentBlobLocally: () => { },
-    getAttachmentBlobLocally: () => undefined,
-});
-export const AttachmentBlobsProvider = ({ children }) => {
-    const [attachmentBlobs, setAttachmentBlobs] = React.useState([]);
-    const storeAttachmentBlobLocally = React.useCallback((newAttachment) => {
-        setAttachmentBlobs((c) => [...c, newAttachment]);
-    }, []);
-    const getAttachmentBlobLocally = React.useCallback((attachmentId) => {
-        return attachmentBlobs.find((b) => b.attachmentId === attachmentId);
-    }, [attachmentBlobs]);
-    const value = React.useMemo(() => ({
-        storeAttachmentBlobLocally,
-        getAttachmentBlobLocally,
-    }), [storeAttachmentBlobLocally, getAttachmentBlobLocally]);
-    return (React.createElement(AttachmentBlobsContext.Provider, { value: value }, children));
-};
-const useAttachmentBlobs = () => {
-    return React.useContext(AttachmentBlobsContext);
-};
-export default useAttachmentBlobs;
+import * as React from 'react';
+const AttachmentBlobsContext = React.createContext({
+    storeAttachmentBlobLocally: () => { },
+    getAttachmentBlobLocally: () => undefined,
+});
+export const AttachmentBlobsProvider = ({ children }) => {
+    const [attachmentBlobs, setAttachmentBlobs] = React.useState([]);
+    const storeAttachmentBlobLocally = React.useCallback((newAttachment) => {
+        setAttachmentBlobs((c) => [...c, newAttachment]);
+    }, []);
+    const getAttachmentBlobLocally = React.useCallback((attachmentId) => {
+        return attachmentBlobs.find((b) => b.attachmentId === attachmentId);
+    }, [attachmentBlobs]);
+    const value = React.useMemo(() => ({
+        storeAttachmentBlobLocally,
+        getAttachmentBlobLocally,
+    }), [storeAttachmentBlobLocally, getAttachmentBlobLocally]);
+    return (React.createElement(AttachmentBlobsContext.Provider, { value: value }, children));
+};
+const useAttachmentBlobs = () => {
+    return React.useContext(AttachmentBlobsContext);
+};
+export default useAttachmentBlobs;
 //# sourceMappingURL=useAttachmentBlobs.js.map

package/dist/hooks/attachments/useAttachmentObjectURLs.d.ts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+declare type AttachmentObjectBlob = {
+    attachmentId: string;
+    blob: Blob;
+};
+declare type RegisterAttachmentParam = {
+    blob: Blob;
+    attachmentId: string;
+};
+declare type ReplacePreUploadIdParam = {
+    attachmentId: string;
+    preUploadId: string;
+};
+declare type AttachmentObjectURLsContextValue = {
+    registerAttachmentObjectURL: (options: RegisterAttachmentParam) => void;
+    replacePreUploadIdWithAttachmentId: (options: ReplacePreUploadIdParam) => void;
+    attachmentObjectURLs: Array<AttachmentObjectBlob>;
+};
+declare type Props = {
+    children: React.ReactNode;
+};
+export declare const AttachmentObjectURLsProvider: ({ children }: Props) => JSX.Element;
+declare const useAttachmentObjectURLs: () => AttachmentObjectURLsContextValue;
+export default useAttachmentObjectURLs;

package/dist/hooks/attachments/useAttachmentObjectURLs.js

@@ -0,0 +1,37 @@
+import * as React from 'react';
+const AttachmentObjectURLsContext = React.createContext({
+    registerAttachmentObjectURL: () => { },
+    replacePreUploadIdWithAttachmentId: () => { },
+    attachmentObjectURLs: [],
+});
+export const AttachmentObjectURLsProvider = ({ children }) => {
+    const [attachmentObjectURLs, setAttachmentObjectURLs] = React.useState([]);
+    const registerAttachmentObjectURL = React.useCallback((newAttachment) => {
+        setAttachmentObjectURLs((c) => [...c, newAttachment]);
+    }, []);
+    const replacePreUploadIdWithAttachmentId = React.useCallback(({ attachmentId: newAttachmentId, preUploadId, }) => {
+        setAttachmentObjectURLs((c) => {
+            return c.map(({ attachmentId, blob }) => {
+                return {
+                    blob,
+                    attachmentId: attachmentId === preUploadId ? newAttachmentId : attachmentId,
+                };
+            });
+        });
+    }, []);
+    const value = React.useMemo(() => ({
+        attachmentObjectURLs,
+        registerAttachmentObjectURL,
+        replacePreUploadIdWithAttachmentId,
+    }), [
+        attachmentObjectURLs,
+        registerAttachmentObjectURL,
+        replacePreUploadIdWithAttachmentId,
+    ]);
+    return (React.createElement(AttachmentObjectURLsContext.Provider, { value: value }, children));
+};
+const useAttachmentObjectURLs = () => {
+    return React.useContext(AttachmentObjectURLsContext);
+};
+export default useAttachmentObjectURLs;
+//# sourceMappingURL=useAttachmentObjectURLs.js.map

package/dist/hooks/attachments/useAttachmentObjectURLs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAttachmentObjectURLs.js","sourceRoot":"","sources":["../../../src/hooks/attachments/useAttachmentObjectURLs.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAwB9B,MAAM,2BAA2B,GAC/B,KAAK,CAAC,aAAa,CAAmC;IACpD,2BAA2B,EAAE,GAAG,EAAE,GAAE,CAAC;IACrC,kCAAkC,EAAE,GAAG,EAAE,GAAE,CAAC;IAC5C,oBAAoB,EAAE,EAAE;CACzB,CAAC,CAAA;AAEJ,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,EAAE,QAAQ,EAAS,EAAE,EAAE;IAClE,MAAM,CAAC,oBAAoB,EAAE,uBAAuB,CAAC,GAAG,KAAK,CAAC,QAAQ,CAEpE,EAAE,CAAC,CAAA;IACL,MAAM,2BAA2B,GAAG,KAAK,CAAC,WAAW,CACnD,CAAC,aAAsC,EAAE,EAAE;QACzC,uBAAuB,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,aAAa,CAAC,CAAC,CAAA;IACvD,CAAC,EACD,EAAE,CACH,CAAA;IAED,MAAM,kCAAkC,GAAG,KAAK,CAAC,WAAW,CAC1D,CAAC,EACC,YAAY,EAAE,eAAe,EAC7B,WAAW,GACa,EAAE,EAAE;QAC5B,uBAAuB,CAAC,CAAC,CAAC,EAAE,EAAE;YAC5B,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,EAAE;gBACtC,OAAO;oBACL,IAAI;oBACJ,YAAY,EACV,YAAY,KAAK,WAAW,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,YAAY;iBAChE,CAAA;YACH,CAAC,CAAC,CAAA;QACJ,CAAC,CAAC,CAAA;IACJ,CAAC,EACD,EAAE,CACH,CAAA;IAED,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CACzB,GAAG,EAAE,CAAC,CAAC;QACL,oBAAoB;QACpB,2BAA2B;QAC3B,kCAAkC;KACnC,CAAC,EACF;QACE,oBAAoB;QACpB,2BAA2B;QAC3B,kCAAkC;KACnC,CACF,CAAA;IAED,OAAO,CACL,oBAAC,2BAA2B,CAAC,QAAQ,IAAC,KAAK,EAAE,KAAK,IAC/C,QAAQ,CAC4B,CACxC,CAAA;AACH,CAAC,CAAA;AAED,MAAM,uBAAuB,GAAG,GAAG,EAAE;IACnC,OAAO,KAAK,CAAC,UAAU,CAAC,2BAA2B,CAAC,CAAA;AACtD,CAAC,CAAA;AACD,eAAe,uBAAuB,CAAA","sourcesContent":["import * as React from 'react'\n\ntype AttachmentObjectBlob = {\n  attachmentId: string\n  blob: Blob\n}\ntype RegisterAttachmentParam = {\n  blob: Blob\n  attachmentId: string\n}\ntype ReplacePreUploadIdParam = {\n  attachmentId: string\n  preUploadId: string\n}\ntype AttachmentObjectURLsContextValue = {\n  registerAttachmentObjectURL: (options: RegisterAttachmentParam) => void\n  replacePreUploadIdWithAttachmentId: (options: ReplacePreUploadIdParam) => void\n  attachmentObjectURLs: Array<AttachmentObjectBlob>\n}\n\ntype Props = {\n  children: React.ReactNode\n}\n\nconst AttachmentObjectURLsContext =\n  React.createContext<AttachmentObjectURLsContextValue>({\n    registerAttachmentObjectURL: () => {},\n    replacePreUploadIdWithAttachmentId: () => {},\n    attachmentObjectURLs: [],\n  })\n\nexport const AttachmentObjectURLsProvider = ({ children }: Props) => {\n  const [attachmentObjectURLs, setAttachmentObjectURLs] = React.useState<\n    AttachmentObjectBlob[]\n  >([])\n  const registerAttachmentObjectURL = React.useCallback(\n    (newAttachment: RegisterAttachmentParam) => {\n      setAttachmentObjectURLs((c) => [...c, newAttachment])\n    },\n    [],\n  )\n\n  const replacePreUploadIdWithAttachmentId = React.useCallback(\n    ({\n      attachmentId: newAttachmentId,\n      preUploadId,\n    }: ReplacePreUploadIdParam) => {\n      setAttachmentObjectURLs((c) => {\n        return c.map(({ attachmentId, blob }) => {\n          return {\n            blob,\n            attachmentId:\n              attachmentId === preUploadId ? newAttachmentId : attachmentId,\n          }\n        })\n      })\n    },\n    [],\n  )\n\n  const value = React.useMemo(\n    () => ({\n      attachmentObjectURLs,\n      registerAttachmentObjectURL,\n      replacePreUploadIdWithAttachmentId,\n    }),\n    [\n      attachmentObjectURLs,\n      registerAttachmentObjectURL,\n      replacePreUploadIdWithAttachmentId,\n    ],\n  )\n\n  return (\n    <AttachmentObjectURLsContext.Provider value={value}>\n      {children}\n    </AttachmentObjectURLsContext.Provider>\n  )\n}\n\nconst useAttachmentObjectURLs = () => {\n  return React.useContext(AttachmentObjectURLsContext)\n}\nexport default useAttachmentObjectURLs\n"]}