@contember/react-client 2.0.0-alpha.4 → 2.0.0-alpha.5

package/src/upload/fileUploadReducer.ts

@@ -1,166 +0,0 @@
-import { FileUploadError } from '@contember/client'
-import { assertNever } from '@contember/utilities'
-import type { FileId } from './FileId'
-import type { FileUploadAction } from './FileUploadAction'
-import type { FileUploadMultiTemporalState } from './FileUploadMultiTemporalState'
-import { toFileId } from './toFileId'
-
-export const initializeFileUploadState = <Result = unknown, Metadata = undefined>(): FileUploadMultiTemporalState<Result, Metadata> => ({
-	fileIdByFile: new WeakMap<File, FileId>(),
-	state: new Map(),
-})
-
-export const fileUploadReducer = <Result = unknown, Metadata = undefined>(
-	previousState: FileUploadMultiTemporalState<Result, Metadata>,
-	action: FileUploadAction<Result, Metadata>,
-): FileUploadMultiTemporalState<Result, Metadata> => {
-	let newState: undefined | FileUploadMultiTemporalState<Result, Metadata>['state'] = undefined
-
-	switch (action.type) {
-		case 'initialize': {
-			for (const [fileId, metadata] of action.files) {
-				// Deliberately allowing starting a new upload with the same id
-				(newState ??= new Map(previousState.state)).set(fileId, {
-					readyState: 'initializing',
-					abortController: metadata.abortController,
-					previewUrl: metadata.previewUrl,
-					file: metadata.file,
-				})
-				// Deliberately mutating
-				previousState.fileIdByFile.set(metadata.file, fileId)
-			}
-			break
-		}
-		case 'startUploading': {
-			for (const [fileOrId, metadata] of action.files) {
-				const fileId = toFileId(previousState, fileOrId)
-				const fileState = (newState ?? previousState.state).get(fileId)
-
-				if (fileState === undefined || fileState.readyState !== 'initializing') {
-					continue
-				}
-
-				(newState ??= new Map(previousState.state)).set(fileId, {
-					readyState: 'uploading',
-					abortController: fileState.abortController,
-					file: fileState.file,
-					metadata: metadata.metadata!, // If the user didn't supply the metadata, then that's on them.
-					previewUrl: fileState.previewUrl,
-					progress: undefined,
-					uploader: metadata.uploader,
-				})
-			}
-			break
-		}
-		case 'finishSuccessfully': {
-			for (const [fileOrId, result] of action.result) {
-				const fileId = toFileId(previousState, fileOrId)
-				const previousFileState = (newState ?? previousState.state).get(fileId)
-				if (previousFileState === undefined || previousFileState.readyState !== 'uploading') {
-					continue
-				}
-				(newState ??= new Map(previousState.state)).set(fileId, {
-					readyState: 'success',
-					file: previousFileState.file,
-					metadata: previousFileState.metadata,
-					previewUrl: previousFileState.previewUrl,
-					result,
-					uploader: previousFileState.uploader,
-				})
-			}
-			break
-		}
-		case 'finishWithError': {
-			for (const errorSpec of action.error) {
-				let fileOrId: File | FileId
-				let rawError: unknown
-
-				if (Array.isArray(errorSpec)) {
-					[fileOrId, rawError] = errorSpec
-				} else {
-					fileOrId = errorSpec
-					rawError = undefined
-				}
-
-				const errors: FileUploadError[] = []
-
-				if (rawError instanceof FileUploadError) {
-					errors.push(rawError)
-				} else if (Array.isArray(rawError)) {
-					for (const error of rawError) {
-						if (error instanceof FileUploadError) {
-							errors.push(error)
-						}
-					}
-				}
-
-				const fileId = toFileId(previousState, fileOrId)
-				const previousFileState = (newState ?? previousState.state).get(fileId)
-				if (
-					previousFileState === undefined ||
-					(previousFileState.readyState !== 'initializing' && previousFileState.readyState !== 'uploading')
-				) {
-					continue
-				}
-				const uploader = previousFileState.readyState === 'uploading' ? previousFileState.uploader : undefined
-				const metadata = previousFileState.readyState === 'uploading' ? previousFileState.metadata : undefined
-					; (newState ??= new Map(previousState.state)).set(fileId, {
-						readyState: 'error',
-						errors: errors.length ? errors : undefined,
-						rawError,
-						file: previousFileState.file,
-						metadata,
-						previewUrl: previousFileState.previewUrl,
-						uploader,
-					})
-			}
-			break
-		}
-		case 'purge': {
-			for (const fileOrId of action.files) {
-				const fileId = toFileId(previousState, fileOrId)
-				const fileState = (newState ?? previousState.state).get(fileId)
-
-				if (fileState === undefined) {
-					continue
-				}
-				URL.revokeObjectURL(fileState.previewUrl)
-				if (fileState.readyState === 'initializing' || fileState.readyState === 'uploading') {
-					fileState.abortController.abort() // This is a bit naughty… We shouldn't do this from here.
-				}
-				(newState ??= new Map(previousState.state)).delete(fileId)
-			}
-			break
-		}
-		case 'updateUploadProgress': {
-			for (const [fileOrId, { progress }] of action.progress) {
-				const fileId = toFileId(previousState, fileOrId)
-				const previousFileState = (newState ?? previousState.state).get(fileId)
-				if (progress === undefined || previousFileState === undefined || previousFileState.readyState !== 'uploading') {
-					continue
-				}
-
-				if (previousFileState.progress && Math.abs(progress - previousFileState.progress) < 0.01) {
-					continue
-				}
-
-				(newState ??= new Map(previousState.state)).set(fileId, {
-					readyState: 'uploading',
-					file: previousFileState.file,
-					uploader: previousFileState.uploader,
-					abortController: previousFileState.abortController,
-					previewUrl: previousFileState.previewUrl,
-					metadata: previousFileState.metadata,
-					progress: progress,
-				})
-			}
-			break
-		}
-		default:
-			assertNever(action)
-	}
-	if (newState === undefined) {
-		return previousState
-	}
-	return { ...previousState, state: newState }
-}

package/src/upload/index.ts

@@ -1,15 +0,0 @@
-export * from './useFileUpload'
-
-export type { FileId } from './FileId'
-export type { FileUploadCompoundState } from './FileUploadCompoundState'
-export type { FileUploadMetadata } from './FileUploadMetadata'
-export type {
-	StartUploadFileOptions,
-	StartUpload,
-	FileUploadOperations,
-	InitializeUpload,
-	PurgeUpload,
-	FailUpload,
-} from './FileUploadOperations'
-export type { FileWithMetadata } from './FileWithMetadata'
-export * from './SingleFileUploadState'

package/src/upload/toFileId.ts

@@ -1,12 +0,0 @@
-import type { FileId } from './FileId'
-import type { FileUploadMultiTemporalState } from './FileUploadMultiTemporalState'
-
-export const toFileId = <Result = unknown, Metadata = undefined>(
-	state: FileUploadMultiTemporalState<Result, Metadata>,
-	fileOrId: File | FileId,
-): FileId => {
-	if (fileOrId instanceof File) {
-		return state.fileIdByFile.get(fileOrId)! // Should we throw instead of the yolo "!"?
-	}
-	return fileOrId
-}

package/src/upload/useFileUpload.ts

@@ -1,218 +0,0 @@
-import { FileUploader, S3FileUploader, UploadedFileMetadata } from '@contember/client'
-import { Reducer, useCallback, useEffect, useMemo, useReducer, useRef } from 'react'
-import { useCurrentContentGraphQlClient } from '../content'
-import type { FileId } from './FileId'
-import type { FileUploadAction } from './FileUploadAction'
-import type { FileUploadCompoundState } from './FileUploadCompoundState'
-import type { FileUploadMetadata } from './FileUploadMetadata'
-import type { FileUploadMultiTemporalState } from './FileUploadMultiTemporalState'
-import type {
-	PurgeUpload,
-	FileUploadOperations,
-	InitializeUpload,
-	StartUpload,
-	StartUploadFileOptions,
-	FailUpload,
-} from './FileUploadOperations'
-import { fileUploadReducer, initializeFileUploadState } from './fileUploadReducer'
-import type { FileWithMetadata } from './FileWithMetadata'
-
-export type FileUpload<Result = unknown, Metadata = undefined> = [
-	FileUploadCompoundState<Result, Metadata>,
-	FileUploadOperations<Metadata>,
-]
-
-export interface FileUploadOptions {
-}
-
-export const useFileUpload = <Result = unknown, Metadata = undefined>({}: FileUploadOptions = {}): FileUpload<Result, Metadata> => {
-	const contentApiClient = useCurrentContentGraphQlClient()
-
-	const fileIdSeedRef = useRef(1)
-
-	const [internalState, dispatch] = useReducer<
-		Reducer<FileUploadMultiTemporalState<Result, Metadata>, FileUploadAction<Result, Metadata>>,
-		undefined
-	>(fileUploadReducer, undefined, initializeFileUploadState)
-
-	const defaultUploader = useMemo(() => new S3FileUploader(), [])
-
-	const purgeUpload = useCallback<PurgeUpload>(files => {
-		dispatch({
-			type: 'purge',
-			files,
-		})
-	}, [])
-	const failUpload = useCallback<FailUpload>(error => {
-		dispatch({
-			type: 'finishWithError',
-			error,
-		})
-	}, [])
-
-	const previewUrls = useRef(new Set<string>())
-	const fileIds = useRef(new WeakMap<File, FileId>())
-	const filesWithMetadataById = useRef(new Map<FileId, WeakRef<FileWithMetadata>>)
-
-	const initializeUpload = useCallback<InitializeUpload>(
-		files => {
-			const newFileIds = new Set<FileId>()
-			const fileWithMetadataByFileConfig = new Map<FileId, FileWithMetadata>()
-
-			for (const fileMaybeWithId of files) {
-				const abortController = new AbortController()
-
-				let fileId: FileId
-				let file: File
-
-				if (fileMaybeWithId instanceof File) {
-					fileId = `__contember__file-${fileIdSeedRef.current++}`
-					file = fileMaybeWithId
-				} else {
-					fileId = fileMaybeWithId[0]
-					file = fileMaybeWithId[1]
-				}
-
-				abortController.signal.addEventListener('abort', () => {
-					purgeUpload([fileId])
-				})
-
-				const previewUrl = URL.createObjectURL(file)
-				const fileWithMetadata: FileWithMetadata = {
-					previewUrl: previewUrl,
-					abortController,
-					file,
-					fileId,
-				}
-				fileWithMetadataByFileConfig.set(fileId, fileWithMetadata)
-
-				newFileIds.add(fileId)
-
-				previewUrls.current.add(previewUrl)
-				fileIds.current.set(file, fileId)
-				filesWithMetadataById.current.set(fileId, new WeakRef(fileWithMetadata))
-			}
-			if (fileWithMetadataByFileConfig.size === 0) {
-				return fileWithMetadataByFileConfig
-			}
-
-			if (newFileIds.size) {
-				dispatch({
-					type: 'purge',
-					files: newFileIds,
-				})
-			}
-
-			dispatch({
-				type: 'initialize',
-				files: fileWithMetadataByFileConfig,
-			})
-
-			return fileWithMetadataByFileConfig
-		},
-		[purgeUpload],
-	)
-	const startUpload = useCallback<StartUpload<Metadata>>(
-		files => {
-			const filesById = new Map<FileId, FileUploadMetadata<Metadata>>()
-			const groupedByUploader: Map<FileUploader, Map<File, UploadedFileMetadata>> = new Map()
-
-			for (const fileOrIdMaybeWithOptions of files) {
-				let fileOrId: File | FileId
-				let options: StartUploadFileOptions<Metadata>
-
-				if (Array.isArray(fileOrIdMaybeWithOptions)) {
-					fileOrId = fileOrIdMaybeWithOptions[0]
-					options = fileOrIdMaybeWithOptions[1]
-				} else {
-					fileOrId = fileOrIdMaybeWithOptions
-					options = {}
-				}
-				const { uploader = defaultUploader, metadata } = options
-
-				const fileId = fileOrId instanceof File ? fileIds.current.get(fileOrId) : fileOrId
-				const fileState = fileId ? filesWithMetadataById.current.get(fileId)?.deref() : undefined
-
-				if (fileId === undefined || fileState === undefined) {
-					throw new Error(
-						`Trying to startUpload a file that hasn't been previously initialized. ` +
-							`This will be possible in future, but isn't yet.`,
-					)
-				}
-
-
-				filesById.set(fileId, {
-					uploader,
-					metadata,
-				})
-
-				let filesWithSameUploader = groupedByUploader.get(uploader)
-				if (filesWithSameUploader === undefined) {
-					groupedByUploader.set(uploader, (filesWithSameUploader = new Map()))
-				}
-				filesWithSameUploader.set(fileState.file, {
-					abortSignal: fileState.abortController.signal,
-				})
-			}
-
-			dispatch({
-				type: 'startUploading',
-				files: filesById,
-			})
-
-			for (const [uploader, filesForUpload] of groupedByUploader) {
-				try {
-					uploader.upload(filesForUpload, {
-						onProgress: progress => {
-							dispatch({
-								type: 'updateUploadProgress',
-								progress,
-							})
-						},
-						onSuccess: result => {
-							dispatch({
-								type: 'finishSuccessfully',
-								result,
-							})
-						},
-						onError: error => {
-							dispatch({
-								type: 'finishWithError',
-								error,
-							})
-						},
-						contentApiClient,
-					})
-				} catch (error) {
-					dispatch({
-						type: 'finishWithError',
-						error: Array.from(filesForUpload).map(([file]) => [file, error]),
-					})
-				}
-			}
-		},
-		[contentApiClient, defaultUploader],
-	)
-
-	const operations = useMemo<FileUploadOperations<Metadata>>(
-		() => ({
-			failUpload,
-			initializeUpload,
-			purgeUpload,
-			startUpload,
-		}),
-		[failUpload, initializeUpload, purgeUpload, startUpload],
-	)
-
-
-	useEffect(
-		() => () => {
-			for (const previewUrl of Array.from(previewUrls.current)) {
-				URL.revokeObjectURL(previewUrl)
-			}
-		},
-		[],
-	)
-
-	return [internalState.state, operations]
-}