@contember/react-client 1.1.0-rc.5 → 1.1.0

package/src/upload/fileUploadReducer.ts

@@ -5,66 +5,42 @@ import type { FileUploadAction } from './FileUploadAction'
 import type { FileUploadMultiTemporalState } from './FileUploadMultiTemporalState'
 import { toFileId } from './toFileId'
 
-export const initializeFileUploadState = <Result = unknown, Metadata = undefined>(): FileUploadMultiTemporalState<
-	Result,
-	Metadata
-> => ({
-	lastUpdateTime: 0,
+export const initializeFileUploadState = <Result = unknown, Metadata = undefined>(): FileUploadMultiTemporalState<Result, Metadata> => ({
 	fileIdByFile: new WeakMap<File, FileId>(),
-	liveState: new Map(),
-	publicState: new Map(),
-	isLiveStateDirty: false,
+	state: new Map(),
 })
 
 export const fileUploadReducer = <Result = unknown, Metadata = undefined>(
 	previousState: FileUploadMultiTemporalState<Result, Metadata>,
 	action: FileUploadAction<Result, Metadata>,
 ): FileUploadMultiTemporalState<Result, Metadata> => {
-	const publishNewState = (): FileUploadMultiTemporalState<Result, Metadata> => ({
-		publicState: previousState.liveState,
-		fileIdByFile: previousState.fileIdByFile,
-		lastUpdateTime: previousState.lastUpdateTime,
-		isLiveStateDirty: false,
+	let newState: undefined | FileUploadMultiTemporalState<Result, Metadata>['state'] = undefined
 
-		// Immediately make the live state referentially unequal so that this doesn't have to happen during each action
-		// several times between two publishes.
-		liveState: new Map(previousState.liveState),
-	})
-	const getNewDirtyState = (): FileUploadMultiTemporalState<Result, Metadata> => ({
-		fileIdByFile: previousState.fileIdByFile,
-		liveState: previousState.liveState,
-		publicState: previousState.publicState,
-		isLiveStateDirty: true,
-		lastUpdateTime: Date.now(),
-	})
 	switch (action.type) {
-		case 'publishNewestState': {
-			return publishNewState()
-		}
 		case 'initialize': {
 			for (const [fileId, metadata] of action.files) {
 				// Deliberately allowing starting a new upload with the same id
-
-				previousState.liveState.set(fileId, {
+				(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)
 			}
-			return publishNewState() /* Making the feedback about new files immediate*/
+			break
 		}
 		case 'startUploading': {
 			for (const [fileOrId, metadata] of action.files) {
 				const fileId = toFileId(previousState, fileOrId)
-				const fileState = previousState.liveState.get(fileId)
+				const fileState = (newState ?? previousState.state).get(fileId)
 
 				if (fileState === undefined || fileState.readyState !== 'initializing') {
 					continue
 				}
 
-				previousState.liveState.set(fileId, {
+				(newState ??= new Map(previousState.state)).set(fileId, {
 					readyState: 'uploading',
 					abortController: fileState.abortController,
 					file: fileState.file,
@@ -74,16 +50,16 @@ export const fileUploadReducer = <Result = unknown, Metadata = undefined>(
 					uploader: metadata.uploader,
 				})
 			}
-			return publishNewState() /* Making the feedback about started upload immediate*/
+			break
 		}
 		case 'finishSuccessfully': {
 			for (const [fileOrId, result] of action.result) {
 				const fileId = toFileId(previousState, fileOrId)
-				const previousFileState = previousState.liveState.get(fileId)
+				const previousFileState = (newState ?? previousState.state).get(fileId)
 				if (previousFileState === undefined || previousFileState.readyState !== 'uploading') {
 					continue
 				}
-				previousState.liveState.set(fileId, {
+				(newState ??= new Map(previousState.state)).set(fileId, {
 					readyState: 'success',
 					file: previousFileState.file,
 					metadata: previousFileState.metadata,
@@ -92,8 +68,7 @@ export const fileUploadReducer = <Result = unknown, Metadata = undefined>(
 					uploader: previousFileState.uploader,
 				})
 			}
-			// return publishNewState() // Making the feedback about successful upload immediate.
-			return getNewDirtyState()
+			break
 		}
 		case 'finishWithError': {
 			for (const errorSpec of action.error) {
@@ -120,7 +95,7 @@ export const fileUploadReducer = <Result = unknown, Metadata = undefined>(
 				}
 
 				const fileId = toFileId(previousState, fileOrId)
-				const previousFileState = previousState.liveState.get(fileId)
+				const previousFileState = (newState ?? previousState.state).get(fileId)
 				if (
 					previousFileState === undefined ||
 					(previousFileState.readyState !== 'initializing' && previousFileState.readyState !== 'uploading')
@@ -129,7 +104,7 @@ export const fileUploadReducer = <Result = unknown, Metadata = undefined>(
 				}
 				const uploader = previousFileState.readyState === 'uploading' ? previousFileState.uploader : undefined
 				const metadata = previousFileState.readyState === 'uploading' ? previousFileState.metadata : undefined
-				previousState.liveState.set(fileId, {
+				;(newState ??= new Map(previousState.state)).set(fileId, {
 					readyState: 'error',
 					errors: errors.length ? errors : undefined,
 					rawError,
@@ -139,47 +114,52 @@ export const fileUploadReducer = <Result = unknown, Metadata = undefined>(
 					uploader,
 				})
 			}
-			return getNewDirtyState() // Bad news can wait.
+			break
 		}
 		case 'purge': {
-			let atLeastOnePurged = false
 			for (const fileOrId of action.files) {
 				const fileId = toFileId(previousState, fileOrId)
-				const fileState = previousState.liveState.get(fileId)
+				const fileState = (newState ?? previousState.state).get(fileId)
 
 				if (fileState === undefined) {
 					continue
 				}
-				atLeastOnePurged = true
+				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.
 				}
-				previousState.liveState.delete(fileId)
-			}
-			if (atLeastOnePurged) {
-				return getNewDirtyState()
+				(newState ??= new Map(previousState.state)).delete(fileId)
 			}
-			return previousState
+			break
 		}
 		case 'updateUploadProgress': {
 			for (const [fileOrId, { progress }] of action.progress) {
 				const fileId = toFileId(previousState, fileOrId)
-				const previousFileState = previousState.liveState.get(fileId)
+				const previousFileState = (newState ?? previousState.state).get(fileId)
 				if (progress === undefined || previousFileState === undefined || previousFileState.readyState !== 'uploading') {
 					continue
 				}
-				previousState.liveState.set(fileId, {
+				const roundedProgress = Math.floor(progress) // throttling
+				if (roundedProgress === previousFileState.progress) {
+					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: roundedProgress,
 				})
 			}
-			return getNewDirtyState()
+			break
 		}
+		default:
+			assertNever(action)
+	}
+	if (newState === undefined) {
+		return previousState
 	}
-	assertNever(action)
+	return { ...previousState, state: newState }
 }

package/src/upload/toFileId.ts

@@ -4,7 +4,7 @@ import type { FileUploadMultiTemporalState } from './FileUploadMultiTemporalStat
 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 "!"?
 	}

package/src/upload/useFileUpload.ts

@@ -16,7 +16,6 @@ import type {
 } from './FileUploadOperations'
 import { fileUploadReducer, initializeFileUploadState } from './fileUploadReducer'
 import type { FileWithMetadata } from './FileWithMetadata'
-import { toFileId } from './toFileId'
 
 export type FileUpload<Result = unknown, Metadata = undefined> = [
 	FileUploadCompoundState<Result, Metadata>,
@@ -24,32 +23,20 @@ export type FileUpload<Result = unknown, Metadata = undefined> = [
 ]
 
 export interface FileUploadOptions {
-	maxUpdateFrequency?: number // This does NOT apply to all kinds of updates.
 }
 
-export const useFileUpload = <Result = unknown, Metadata = undefined>(
-	options?: FileUploadOptions,
-): FileUpload<Result, Metadata> => {
-	const maxUpdateFrequency = options?.maxUpdateFrequency ?? 100
-
+export const useFileUpload = <Result = unknown, Metadata = undefined>({}: FileUploadOptions = {}): FileUpload<Result, Metadata> => {
 	const contentApiClient = useCurrentContentGraphQlClient()
 
-	const updateTimeoutRef = useRef<number | undefined>(undefined)
-	const isFirstRenderRef = useRef(true)
 	const fileIdSeedRef = useRef(1)
 
-	const [multiTemporalState, dispatch] = useReducer<
+	const [internalState, dispatch] = useReducer<
 		Reducer<FileUploadMultiTemporalState<Result, Metadata>, FileUploadAction<Result, Metadata>>,
 		undefined
 	>(fileUploadReducer, undefined, initializeFileUploadState)
-	const multiTemporalStateRef = useRef(multiTemporalState)
 
 	const defaultUploader = useMemo(() => new S3FileUploader(), [])
 
-	useEffect(() => {
-		multiTemporalStateRef.current = multiTemporalState
-	})
-
 	const purgeUpload = useCallback<PurgeUpload>(files => {
 		dispatch({
 			type: 'purge',
@@ -62,6 +49,11 @@ export const useFileUpload = <Result = unknown, Metadata = undefined>(
 			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>()
@@ -85,14 +77,20 @@ export const useFileUpload = <Result = unknown, Metadata = undefined>(
 					purgeUpload([fileId])
 				})
 
-				fileWithMetadataByFileConfig.set(fileId, {
-					previewUrl: URL.createObjectURL(file),
+				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
@@ -119,8 +117,6 @@ export const useFileUpload = <Result = unknown, Metadata = undefined>(
 			const filesById = new Map<FileId, FileUploadMetadata<Metadata>>()
 			const groupedByUploader: Map<FileUploader, Map<File, UploadedFileMetadata>> = new Map()
 
-			const currentState = multiTemporalStateRef.current
-
 			for (const fileOrIdMaybeWithOptions of files) {
 				let fileOrId: File | FileId
 				let options: StartUploadFileOptions<Metadata>
@@ -134,16 +130,17 @@ export const useFileUpload = <Result = unknown, Metadata = undefined>(
 				}
 				const { uploader = defaultUploader, metadata } = options
 
-				const fileId = toFileId(currentState, fileOrId)
-				const fileState = currentState.liveState.get(fileId)
+				const fileId = fileOrId instanceof File ? fileIds.current.get(fileOrId) : fileOrId
+				const fileState = fileId ? filesWithMetadataById.current.get(fileId)?.deref() : undefined
 
-				if (fileState === undefined || fileState.readyState !== 'initializing') {
+				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,
@@ -207,56 +204,15 @@ export const useFileUpload = <Result = unknown, Metadata = undefined>(
 		[failUpload, initializeUpload, purgeUpload, startUpload],
 	)
 
-	useEffect(() => {
-		if (isFirstRenderRef.current) {
-			return
-		}
-		if (multiTemporalState.isLiveStateDirty) {
-			const now = Date.now()
-			const timeDelta = Math.max(now - multiTemporalState.lastUpdateTime, 0) // The max is just a sanity check
-			if (timeDelta > maxUpdateFrequency) {
-				if (updateTimeoutRef.current !== undefined) {
-					clearTimeout(updateTimeoutRef.current)
-				}
-				dispatch({
-					type: 'publishNewestState',
-				})
-			} else {
-				if (updateTimeoutRef.current !== undefined) {
-					return
-				}
-				updateTimeoutRef.current = window.setTimeout(() => {
-					dispatch({
-						type: 'publishNewestState',
-					})
-					updateTimeoutRef.current = undefined
-				}, maxUpdateFrequency - timeDelta)
-			}
-		}
-	}, [
-		multiTemporalState.isLiveStateDirty,
-		multiTemporalState.lastUpdateTime,
-		multiTemporalState.liveState,
-		multiTemporalState.publicState,
-		maxUpdateFrequency,
-	])
 
 	useEffect(
 		() => () => {
-			for (const [, state] of multiTemporalStateRef.current.liveState) {
-				URL.revokeObjectURL(state.previewUrl)
-			}
-			for (const [, state] of multiTemporalStateRef.current.publicState) {
-				URL.revokeObjectURL(state.previewUrl)
+			for (const previewUrl of Array.from(previewUrls.current)) {
+				URL.revokeObjectURL(previewUrl)
 			}
 		},
 		[],
 	)
 
-	// For this to work, this effect must be the last one to run.
-	useEffect(() => {
-		isFirstRenderRef.current = false
-	}, [])
-
-	return [multiTemporalState.publicState, operations]
+	return [internalState.state, operations]
 }

package/LICENSE

@@ -1,186 +0,0 @@
-Copyright (c) 2022 Contember Limited
-
-Portions of this software are licensed as follows:
-
-* All content that resides under the "EE/" directory of this repository, if that directory exists, is licensed under the license defined in "EE/LICENSE".
-* All third party components incorporated into the Contember/Admin are licensed under the original license provided by the owner of the applicable component.
-* Content outside of the above mentioned directories or restrictions above is available under the Apache License, Version 2.0 (the "License") as defined below.
-
--------------------------------------------------------------------------
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS