@firecms/core 3.3.0-canary.d3242eb → 3.4.0-canary.00f9be5

package/src/util/previews.ts

@@ -1,4 +1,4 @@
-import { AuthController, EntityCollection, Property, PropertyConfig, ResolvedEntityCollection } from "../types";
+import { AuthController, EntityCollection, Property, PropertyConfig, ResolvedEntityCollection, ResolvedProperties } from "../types";
 import { isReferenceProperty } from "./property_utils";
 import { isPropertyBuilder } from "./entities";
 import { getFieldConfig } from "../core";
@@ -44,6 +44,13 @@ export function getEntityTitlePropertyKey<M extends Record<string, any>>(collect
 
 export function getEntityImagePreviewPropertyKey<M extends object>(collection: ResolvedEntityCollection<M>): string | undefined {
 
+    if (collection.imageProperty) {
+        const imagePropertyKey = collection.imageProperty as keyof ResolvedProperties<M>;
+        if (collection.properties[imagePropertyKey]) {
+            return collection.imageProperty as string;
+        }
+    }
+
     // find first storage property of type image
     for (const key in collection.properties) {
         const property = collection.properties[key];

package/src/util/resolutions.ts

@@ -90,8 +90,11 @@ export const resolveCollection = <M extends Record<string, any>,>
         .map(([id, property]) => ({ [id]: property }))
         .reduce((a, b) => ({ ...a, ...b }), {});
 
+    const { properties: overrideProps, ...restOverrides } = collectionOverride ?? {};
+
     return {
         ...collection,
+        ...restOverrides,
         properties: cleanedProperties,
         originalCollection: collection
     } as ResolvedEntityCollection<M>;
@@ -302,7 +305,15 @@ export function resolveArrayProperty<T extends any[], M>({
                 ignoreMissingFields,
                 ...props
             });
+            // `of` describes the shape of any element of the array, not one
+            // specific element, so there is no index to qualify the key with.
+            // We pass the array's own key, mirroring what the `oneOf` branch
+            // below does for `oneOf.properties`. Without this, a property
+            // builder used as `of` (or nested inside it) would be invoked with
+            // `propertyKey: undefined`, while the per-index resolutions above
+            // receive `${propertyKey}.${index}`.
             const ofProperty = resolveProperty({
+                propertyKey,
                 propertyOrBuilder: of,
                 ignoreMissingFields,
                 ...props

package/src/util/urls.ts

@@ -0,0 +1,52 @@
+import type { PreviewType } from "../types";
+
+const ABSOLUTE_HTTP_URL_REGEX = /^https?:\/\//i;
+
+const IMAGE_EXTENSIONS = ["jpg", "jpeg", "png", "gif", "webp", "avif", "bmp", "svg", "ico", "tif", "tiff", "heic", "heif"];
+const VIDEO_EXTENSIONS = ["mp4", "webm", "ogv", "mov", "m4v", "avi", "mkv", "mpeg", "mpg", "3gp"];
+const AUDIO_EXTENSIONS = ["mp3", "wav", "ogg", "oga", "m4a", "aac", "flac", "weba", "opus", "mid", "midi"];
+
+/**
+ * Is the given value an absolute `http(s)` URL, as opposed to a relative
+ * storage path such as `images/my_image.png`?
+ *
+ * Values saved in the datasource for storage properties can be either, e.g.
+ * when the property is configured with `storeUrl: true`, or when the value was
+ * written directly pointing to an externally hosted file.
+ */
+export function isAbsoluteHttpUrl(value?: string | null): boolean {
+    if (!value) return false;
+    return ABSOLUTE_HTTP_URL_REGEX.test(value);
+}
+
+/**
+ * Extract the lowercase file extension of a URL or path, ignoring any query
+ * string or hash fragment. Returns `undefined` when there is no extension.
+ */
+export function getFileExtensionFromUrl(urlOrPath?: string | null): string | undefined {
+    if (!urlOrPath) return undefined;
+    // Query strings and hash fragments are not part of the file name, and they
+    // are common in download URLs, e.g. `?alt=media&token=...`
+    const withoutQuery = urlOrPath.split(/[?#]/)[0];
+    const lastSegment = withoutQuery.split("/").pop();
+    if (!lastSegment) return undefined;
+    const lastDot = lastSegment.lastIndexOf(".");
+    // No dot, a leading dot (a dotfile), or a trailing dot means no extension
+    if (lastDot <= 0 || lastDot === lastSegment.length - 1) return undefined;
+    return lastSegment.substring(lastDot + 1).toLowerCase();
+}
+
+/**
+ * Best effort guess of the preview type of a URL or path, based on its file
+ * extension. Used when no storage metadata (and therefore no content type) is
+ * available, e.g. for externally hosted files.
+ * Returns `undefined` when the extension is missing or not recognised.
+ */
+export function getPreviewTypeFromUrl(urlOrPath?: string | null): PreviewType | undefined {
+    const extension = getFileExtensionFromUrl(urlOrPath);
+    if (!extension) return undefined;
+    if (IMAGE_EXTENSIONS.includes(extension)) return "image";
+    if (VIDEO_EXTENSIONS.includes(extension)) return "video";
+    if (AUDIO_EXTENSIONS.includes(extension)) return "audio";
+    return undefined;
+}

package/src/util/useStorageUploadController.tsx

@@ -1,4 +1,4 @@
-import Compressor from "compressorjs";
+import type CompressorType from "compressorjs";
 import equal from "react-fast-compare";
 
 import {
@@ -321,6 +321,11 @@ export async function resizeImage(
         mimeType = `image/${imageResize.format}`;
     }
 
+    // Loaded here rather than imported: compressing an image is something a
+    // small fraction of sessions ever does, and a static import put the library
+    // in `@firecms/core` for everyone.
+    const Compressor: typeof CompressorType = (await import("compressorjs")).default;
+
     return new Promise<File>((resolve, reject) => {
         new Compressor(file, {
             quality,