Skip to content

Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.

fix: Support woff2 upload from asset manager (#5559)

Oleg Isonen763064e850e8
diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index db09e733f5..56d8735441 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -10,6 +10,18 @@
- Never use arbitrary CSS number values, 99% of the time you need to use a value from the theme
- Never use margin, always use gap or padding
- Never use one-line if statements: `if (condition) something;`
+- Functions must never have more than 3 parameters - use an object parameter instead
+
+## Running Checks
+
+- When user says "run checks" or similar, always run both `pnpm eslint` and `pnpm typecheck` (not just `get_errors`)
+- Fix all eslint and TypeScript errors before considering work complete
+
+## File Organization
+
+- Files named `types.ts` must only contain TypeScript type definitions, interfaces, and type aliases
+- Never add functions, constants, or executable code to `types.ts` files
+- Place utility functions in `*-utils.ts` files, constants in `constants.ts`, etc.
## Testing
diff --git a/apps/builder/app/builder/features/pages/image-info.tsx b/apps/builder/app/builder/features/pages/image-info.tsx
index 4da7102668..d64ef26ed9 100644
--- a/apps/builder/app/builder/features/pages/image-info.tsx
+++ b/apps/builder/app/builder/features/pages/image-info.tsx
@@ -13,7 +13,7 @@ import {
} from "@webstudio-is/icons";
import type { ImageAsset } from "@webstudio-is/sdk";
import { formatAssetName } from "~/builder/shared/assets/asset-utils";
-import { getFormattedAspectRatio } from "~/builder/shared/asset-manager/utils";
+import { getFormattedAspectRatio } from "~/builder/shared/asset-manager";
type ImageInfoProps = {
asset: ImageAsset;
diff --git a/apps/builder/app/builder/shared/asset-manager/asset-manager.tsx b/apps/builder/app/builder/shared/asset-manager/asset-manager.tsx
index 6f1f3dd5f8..0753bf4fc3 100644
--- a/apps/builder/app/builder/shared/asset-manager/asset-manager.tsx
+++ b/apps/builder/app/builder/shared/asset-manager/asset-manager.tsx
@@ -1,5 +1,4 @@
import { useState, useMemo } from "react";
-import { matchSorter } from "match-sorter";
import {
Flex,
Grid,
@@ -8,59 +7,48 @@ import {
useSearchFieldKeys,
} from "@webstudio-is/design-system";
import type { Asset, AllowedFileExtension } from "@webstudio-is/sdk";
-import {
- acceptToMimePatterns,
- doesAssetMatchMimePatterns,
-} from "@webstudio-is/sdk";
import { AssetsShell, type AssetContainer, useAssets } from "../assets";
import { AssetThumbnail } from "./asset-thumbnail";
import { AssetFilters } from "./asset-filters";
-import { AssetSortSelect, sortAssets, type SortState } from "./asset-sort";
+import { AssetSortSelect } from "./asset-sort";
+import {
+ getInitialExtensions,
+ calculateFormatCounts,
+ filterAndSortAssets,
+ findAssetIndex,
+ type SortState,
+} from "./utils";
-const useLogic = ({
- onChange,
- accept = "*",
-}: {
+type AssetManagerProps = {
onChange?: (assetId: Asset["id"]) => void;
+ /** acceptable file types in the `<imput accept>` attribute format */
accept?: string;
-}) => {
+};
+
+export const AssetManager = ({ accept = "*", onChange }: AssetManagerProps) => {
const { assetContainers } = useAssets();
const [selectedIndex, setSelectedIndex] = useState(-1);
- // Initialize selectedExtensions based on accept prop
const [selectedExtensions, setSelectedExtensions] = useState<
AllowedFileExtension[] | "*"
- >(() => {
- const patterns = acceptToMimePatterns(accept);
- if (patterns === "*") {
- return "*";
- }
- // Convert MIME patterns to extensions
- const extensions: AllowedFileExtension[] = [];
- assetContainers.forEach((container) => {
- if (doesAssetMatchMimePatterns(container.asset, patterns)) {
- const ext =
- container.asset.format.toLowerCase() as AllowedFileExtension;
- if (!extensions.includes(ext)) {
- extensions.push(ext);
- }
- }
- });
- return extensions.length > 0 ? extensions : "*";
- });
+ >(() => getInitialExtensions(accept, assetContainers));
const [sortState, setSortState] = useState<SortState>({
sortBy: "createdAt",
order: "desc",
});
+ const formatCounts = useMemo(
+ () => calculateFormatCounts(assetContainers),
+ [assetContainers]
+ );
+
const searchProps = useSearchFieldKeys({
onMove({ direction }) {
if (direction === "current") {
- setSelectedIndex(selectedIndex);
const assetContainer = filteredItems[selectedIndex];
- if (assetContainer.status === "uploaded") {
+ if (assetContainer?.status === "uploaded") {
onChange?.(assetContainer.asset.id);
}
return;
@@ -74,90 +62,21 @@ const useLogic = ({
},
});
- // Filter assets by accept prop first to get the base set
- const acceptableAssets = useMemo(() => {
- return assetContainers;
- }, [assetContainers]);
-
- // Get available format counts based on all assets
- const formatCounts = useMemo(() => {
- const counts: Partial<Record<AllowedFileExtension, number>> = {};
-
- assetContainers.forEach((container) => {
- const format =
- container.asset.format.toLowerCase() as AllowedFileExtension;
- counts[format] = (counts[format] || 0) + 1;
- });
-
- return counts;
- }, [assetContainers]);
-
- const filteredItems = useMemo(() => {
- // Start with all assets
- let acceptable = acceptableAssets;
-
- // Filter by selected extensions (user's category selection)
- if (selectedExtensions !== "*") {
- acceptable = acceptable.filter((item) =>
- selectedExtensions.includes(
- item.asset.format.toLowerCase() as AllowedFileExtension
- )
- );
- }
-
- let result = acceptable;
- if (searchProps.value !== "") {
- result = matchSorter(acceptable, searchProps.value, {
- keys: [(item) => item.asset.name],
- });
- }
-
- // Apply sorting
- return sortAssets(result, sortState);
- }, [acceptableAssets, searchProps.value, selectedExtensions, sortState]);
+ const filteredItems = useMemo(
+ () =>
+ filterAndSortAssets({
+ assetContainers,
+ selectedExtensions,
+ searchQuery: searchProps.value,
+ sortState,
+ }),
+ [assetContainers, selectedExtensions, searchProps.value, sortState]
+ );
const handleSelect = (assetContainer?: AssetContainer) => {
- const selectedIndex = filteredItems.findIndex(
- (item) => item.asset.id === assetContainer?.asset.id
- );
- setSelectedIndex(selectedIndex);
+ setSelectedIndex(findAssetIndex(filteredItems, assetContainer?.asset.id));
};
- return {
- searchProps,
- filteredItems,
- handleSelect,
- selectedIndex,
- formatCounts,
- selectedExtensions,
- setSelectedExtensions,
- sortState,
- setSortState,
- };
-};
-
-type AssetManagerProps = {
- onChange?: (assetId: Asset["id"]) => void;
- /** acceptable file types in the `<imput accept>` attribute format */
- accept?: string;
-};
-
-export const AssetManager = ({ accept, onChange }: AssetManagerProps) => {
- const {
- handleSelect,
- filteredItems,
- searchProps,
- selectedIndex,
- formatCounts,
- selectedExtensions,
- setSelectedExtensions,
- sortState,
- setSortState,
- } = useLogic({
- onChange,
- accept,
- });
-
return (
<AssetsShell
filters={
diff --git a/apps/builder/app/builder/shared/asset-manager/asset-sort.tsx b/apps/builder/app/builder/shared/asset-manager/asset-sort.tsx
index 750467369d..9c09aa51c4 100644
--- a/apps/builder/app/builder/shared/asset-manager/asset-sort.tsx
+++ b/apps/builder/app/builder/shared/asset-manager/asset-sort.tsx
@@ -17,49 +17,7 @@ import {
ArrowDownWideNarrowIcon,
ArrowDownNarrowWideIcon,
} from "@webstudio-is/icons";
-import type { AssetContainer } from "../assets";
-
-export type SortField = "name" | "size" | "createdAt";
-export type SortOrder = "asc" | "desc";
-
-export type SortState = {
- sortBy: SortField;
- order: SortOrder;
-};
-
-export const sortAssets = (
- assetContainers: AssetContainer[],
- sortState: SortState
-): AssetContainer[] => {
- const { sortBy, order } = sortState;
- const sorted = [...assetContainers];
-
- sorted.sort((a, b) => {
- let comparison = 0;
-
- if (sortBy === "name") {
- const aName = a.asset.name.toLowerCase();
- const bName = b.asset.name.toLowerCase();
- comparison = aName.localeCompare(bName);
- } else if (sortBy === "size") {
- // Uploading assets don't have size yet, put them at the end
- const aSize =
- a.status === "uploaded" ? a.asset.size : Number.MAX_SAFE_INTEGER;
- const bSize =
- b.status === "uploaded" ? b.asset.size : Number.MAX_SAFE_INTEGER;
- comparison = aSize - bSize;
- } else if (sortBy === "createdAt") {
- // Uploading assets don't have createdAt yet, put them at the end
- const aCreated = a.status === "uploaded" ? a.asset.createdAt || "" : "";
- const bCreated = b.status === "uploaded" ? b.asset.createdAt || "" : "";
- comparison = new Date(aCreated).getTime() - new Date(bCreated).getTime();
- }
-
- return order === "asc" ? comparison : -comparison;
- });
-
- return sorted;
-};
+import type { SortState, SortField, SortOrder } from "./utils";
type AssetSortSelectProps = {
value: SortState;
diff --git a/apps/builder/app/builder/shared/asset-manager/index.ts b/apps/builder/app/builder/shared/asset-manager/index.ts
index afdab79767..8d90f564cc 100644
--- a/apps/builder/app/builder/shared/asset-manager/index.ts
+++ b/apps/builder/app/builder/shared/asset-manager/index.ts
@@ -1 +1,2 @@
export * from "./asset-manager";
+export { getFormattedAspectRatio } from "./utils";
diff --git a/apps/builder/app/builder/shared/asset-manager/utils.test.ts b/apps/builder/app/builder/shared/asset-manager/utils.test.ts
new file mode 100644
index 0000000000..155b23e4e2
--- /dev/null
+++ b/apps/builder/app/builder/shared/asset-manager/utils.test.ts
@@ -0,0 +1,402 @@
+import { describe, test, expect } from "vitest";
+import type { AssetContainer } from "../assets";
+import type { Asset } from "@webstudio-is/sdk";
+import {
+ getInitialExtensions,
+ calculateFormatCounts,
+ filterAndSortAssets,
+ findAssetIndex,
+ sortAssets,
+ getAssetFormat,
+ type SortState,
+} from "./utils";
+
+const createAssetContainer = (
+ id: string,
+ name: string,
+ format: string,
+ type: string,
+ createdAt: string
+): AssetContainer =>
+ ({
+ status: "uploaded" as const,
+ asset: {
+ id,
+ name,
+ format,
+ type,
+ createdAt,
+ projectId: "test-project",
+ size: 1000,
+ },
+ }) as AssetContainer;
+
+describe("getAssetFormat", () => {
+ test("returns lowercase format", () => {
+ const asset = { format: "JPEG" } as Pick<Asset, "format">;
+ expect(getAssetFormat(asset)).toBe("jpeg");
+ });
+
+ test("handles already lowercase format", () => {
+ const asset = { format: "png" } as Pick<Asset, "format">;
+ expect(getAssetFormat(asset)).toBe("png");
+ });
+
+ test("handles mixed case format", () => {
+ const asset = { format: "WoFf2" } as Pick<Asset, "format">;
+ expect(getAssetFormat(asset)).toBe("woff2");
+ });
+
+ test("returns undefined for undefined format", () => {
+ const asset = { format: undefined } as unknown as Pick<Asset, "format">;
+ expect(getAssetFormat(asset)).toBeUndefined();
+ });
+
+ test("handles empty string format", () => {
+ const asset = { format: "" } as Pick<Asset, "format">;
+ expect(getAssetFormat(asset)).toBe("");
+ });
+});
+
+describe("getInitialExtensions", () => {
+ test("returns * for wildcard accept", () => {
+ const containers: AssetContainer[] = [];
+ expect(getInitialExtensions("*", containers)).toBe("*");
+ });
+
+ test("returns * for empty accept", () => {
+ const containers: AssetContainer[] = [];
+ expect(getInitialExtensions("", containers)).toBe("*");
+ });
+
+ test("extracts extensions from containers matching accept pattern", () => {
+ const containers = [
+ createAssetContainer("1", "image.jpg", "jpeg", "image", "2024-01-01"),
+ createAssetContainer("2", "image.png", "png", "image", "2024-01-02"),
+ createAssetContainer("3", "font.woff2", "woff2", "font", "2024-01-03"),
+ ];
+ const result = getInitialExtensions("image/*", containers);
+ expect(result).toEqual(["jpeg", "png"]);
+ });
+
+ test("does not include duplicate extensions", () => {
+ const containers = [
+ createAssetContainer("1", "image1.jpg", "jpeg", "image", "2024-01-01"),
+ createAssetContainer("2", "image2.jpg", "jpeg", "image", "2024-01-02"),
+ ];
+ const result = getInitialExtensions("image/*", containers);
+ expect(result).toEqual(["jpeg"]);
+ });
+
+ test("returns * when no containers match", () => {
+ const containers = [
+ createAssetContainer("1", "font.woff2", "woff2", "font", "2024-01-01"),
+ ];
+ const result = getInitialExtensions("image/*", containers);
+ expect(result).toBe("*");
+ });
+});
+
+describe("calculateFormatCounts", () => {
+ test("counts formats correctly", () => {
+ const containers = [
+ createAssetContainer("1", "image1.jpg", "jpeg", "image", "2024-01-01"),
+ createAssetContainer("2", "image2.jpg", "jpeg", "image", "2024-01-02"),
+ createAssetContainer("3", "image.png", "png", "image", "2024-01-03"),
+ createAssetContainer("4", "font.woff2", "woff2", "font", "2024-01-04"),
+ ];
+ const counts = calculateFormatCounts(containers);
+ expect(counts).toEqual({
+ jpeg: 2,
+ png: 1,
+ woff2: 1,
+ });
+ });
+
+ test("returns empty object for empty containers", () => {
+ const counts = calculateFormatCounts([]);
+ expect(counts).toEqual({});
+ });
+
+ test("skips assets with undefined format", () => {
+ const containers = [
+ createAssetContainer("1", "image.jpg", "jpeg", "image", "2024-01-01"),
+ {
+ status: "uploaded" as const,
+ asset: {
+ id: "2",
+ name: "no-format",
+ format: undefined,
+ type: "file",
+ createdAt: "2024-01-02",
+ projectId: "test-project",
+ size: 1000,
+ },
+ } as unknown as AssetContainer,
+ ];
+ const counts = calculateFormatCounts(containers);
+ expect(counts).toEqual({ jpeg: 1 });
+ });
+});
+
+describe("filterAndSortAssets", () => {
+ const containers = [
+ createAssetContainer("1", "apple.jpg", "jpeg", "image", "2024-01-01"),
+ createAssetContainer("2", "banana.png", "png", "image", "2024-01-02"),
+ createAssetContainer("3", "cherry.jpg", "jpeg", "image", "2024-01-03"),
+ createAssetContainer("4", "date.woff2", "woff2", "font", "2024-01-04"),
+ ];
+
+ test("returns all assets when selectedExtensions is *", () => {
+ const sortState: SortState = { sortBy: "createdAt", order: "asc" };
+ const result = filterAndSortAssets({
+ assetContainers: containers,
+ selectedExtensions: "*",
+ searchQuery: "",
+ sortState,
+ });
+ expect(result).toHaveLength(4);
+ });
+
+ test("filters by selected extensions", () => {
+ const sortState: SortState = { sortBy: "createdAt", order: "asc" };
+ const result = filterAndSortAssets({
+ assetContainers: containers,
+ selectedExtensions: ["jpeg"],
+ searchQuery: "",
+ sortState,
+ });
+ expect(result).toHaveLength(2);
+ expect(result.every((c) => c.asset.format === "jpeg")).toBe(true);
+ });
+
+ test("filters by search query", () => {
+ const sortState: SortState = { sortBy: "createdAt", order: "asc" };
+ const result = filterAndSortAssets({
+ assetContainers: containers,
+ selectedExtensions: "*",
+ searchQuery: "apple",
+ sortState,
+ });
+ expect(result).toHaveLength(1);
+ expect(result[0].asset.name).toBe("apple.jpg");
+ });
+
+ test("applies both extension filter and search", () => {
+ const sortState: SortState = { sortBy: "createdAt", order: "asc" };
+ const result = filterAndSortAssets({
+ assetContainers: containers,
+ selectedExtensions: ["jpeg", "png"],
+ searchQuery: "a",
+ sortState,
+ });
+ expect(result).toHaveLength(2);
+ expect(result.map((c) => c.asset.name)).toEqual([
+ "apple.jpg",
+ "banana.png",
+ ]);
+ });
+
+ test("returns empty array when no matches", () => {
+ const sortState: SortState = { sortBy: "createdAt", order: "asc" };
+ const result = filterAndSortAssets({
+ assetContainers: containers,
+ selectedExtensions: ["jpeg"],
+ searchQuery: "xyz",
+ sortState,
+ });
+ expect(result).toHaveLength(0);
+ });
+});
+
+describe("findAssetIndex", () => {
+ const containers = [
+ createAssetContainer("1", "apple.jpg", "jpeg", "image", "2024-01-01"),
+ createAssetContainer("2", "banana.png", "png", "image", "2024-01-02"),
+ createAssetContainer("3", "cherry.jpg", "jpeg", "image", "2024-01-03"),
+ ];
+
+ test("finds asset index by id", () => {
+ expect(findAssetIndex(containers, "2")).toBe(1);
+ });
+
+ test("returns -1 for non-existent id", () => {
+ expect(findAssetIndex(containers, "999")).toBe(-1);
+ });
+
+ test("returns -1 for undefined id", () => {
+ expect(findAssetIndex(containers, undefined)).toBe(-1);
+ });
+
+ test("finds first asset", () => {
+ expect(findAssetIndex(containers, "1")).toBe(0);
+ });
+
+ test("finds last asset", () => {
+ expect(findAssetIndex(containers, "3")).toBe(2);
+ });
+});
+
+describe("sortAssets", () => {
+ const containers = [
+ createAssetContainer("1", "zebra.jpg", "jpeg", "image", "2024-01-03"),
+ createAssetContainer("2", "apple.png", "png", "image", "2024-01-01"),
+ createAssetContainer("3", "mango.jpg", "jpeg", "image", "2024-01-02"),
+ ];
+
+ test("sorts by name ascending", () => {
+ const result = sortAssets(containers, { sortBy: "name", order: "asc" });
+ expect(result.map((c) => c.asset.name)).toEqual([
+ "apple.png",
+ "mango.jpg",
+ "zebra.jpg",
+ ]);
+ });
+
+ test("sorts by name descending", () => {
+ const result = sortAssets(containers, { sortBy: "name", order: "desc" });
+ expect(result.map((c) => c.asset.name)).toEqual([
+ "zebra.jpg",
+ "mango.jpg",
+ "apple.png",
+ ]);
+ });
+
+ test("sorts by createdAt ascending", () => {
+ const result = sortAssets(containers, {
+ sortBy: "createdAt",
+ order: "asc",
+ });
+ expect(result.map((c) => c.asset.id)).toEqual(["2", "3", "1"]);
+ });
+
+ test("sorts by createdAt descending", () => {
+ const result = sortAssets(containers, {
+ sortBy: "createdAt",
+ order: "desc",
+ });
+ expect(result.map((c) => c.asset.id)).toEqual(["1", "3", "2"]);
+ });
+
+ test("sorts by size ascending", () => {
+ const smallFile = {
+ status: "uploaded" as const,
+ asset: {
+ id: "small",
+ name: "small.jpg",
+ format: "jpeg",
+ type: "image",
+ createdAt: "2024-01-01",
+ projectId: "test-project",
+ size: 100,
+ },
+ } as AssetContainer;
+
+ const largeFile = {
+ status: "uploaded" as const,
+ asset: {
+ id: "large",
+ name: "large.jpg",
+ format: "jpeg",
+ type: "image",
+ createdAt: "2024-01-02",
+ projectId: "test-project",
+ size: 1000,
+ },
+ } as AssetContainer;
+
+ const result = sortAssets([largeFile, smallFile], {
+ sortBy: "size",
+ order: "asc",
+ });
+ expect(result.map((c) => c.asset.id)).toEqual(["small", "large"]);
+ });
+
+ test("sorts by size descending", () => {
+ const smallFile = {
+ status: "uploaded" as const,
+ asset: {
+ id: "small",
+ name: "small.jpg",
+ format: "jpeg",
+ type: "image",
+ createdAt: "2024-01-01",
+ projectId: "test-project",
+ size: 100,
+ },
+ } as AssetContainer;
+
+ const largeFile = {
+ status: "uploaded" as const,
+ asset: {
+ id: "large",
+ name: "large.jpg",
+ format: "jpeg",
+ type: "image",
+ createdAt: "2024-01-02",
+ projectId: "test-project",
+ size: 1000,
+ },
+ } as AssetContainer;
+
+ const result = sortAssets([smallFile, largeFile], {
+ sortBy: "size",
+ order: "desc",
+ });
+ expect(result.map((c) => c.asset.id)).toEqual(["large", "small"]);
+ });
+
+ test("puts uploading assets at the end when sorting by size", () => {
+ const uploadedFile = {
+ status: "uploaded" as const,
+ asset: {
+ id: "uploaded",
+ name: "uploaded.jpg",
+ format: "jpeg",
+ type: "image",
+ createdAt: "2024-01-01",
+ projectId: "test-project",
+ size: 500,
+ },
+ } as AssetContainer;
+
+ const uploadingFile = {
+ status: "uploading" as const,
+ asset: {
+ id: "uploading",
+ name: "uploading.jpg",
+ format: "jpeg",
+ type: "image",
+ projectId: "test-project",
+ },
+ objectURL: "blob:...",
+ } as AssetContainer;
+
+ const result = sortAssets([uploadingFile, uploadedFile], {
+ sortBy: "size",
+ order: "asc",
+ });
+ expect(result.map((c) => c.asset.id)).toEqual(["uploaded", "uploading"]);
+ });
+
+ test("is case-insensitive when sorting by name", () => {
+ const containers = [
+ createAssetContainer("1", "Zebra.jpg", "jpeg", "image", "2024-01-01"),
+ createAssetContainer("2", "apple.png", "png", "image", "2024-01-02"),
+ createAssetContainer("3", "MANGO.jpg", "jpeg", "image", "2024-01-03"),
+ ];
+
+ const result = sortAssets(containers, { sortBy: "name", order: "asc" });
+ expect(result.map((c) => c.asset.name)).toEqual([
+ "apple.png",
+ "MANGO.jpg",
+ "Zebra.jpg",
+ ]);
+ });
+
+ test("does not mutate original array", () => {
+ const original = [...containers];
+ sortAssets(containers, { sortBy: "name", order: "asc" });
+ expect(containers).toEqual(original);
+ });
+});
diff --git a/apps/builder/app/builder/shared/asset-manager/utils.ts b/apps/builder/app/builder/shared/asset-manager/utils.ts
index 029a0de0b3..e73c9f8ab6 100644
--- a/apps/builder/app/builder/shared/asset-manager/utils.ts
+++ b/apps/builder/app/builder/shared/asset-manager/utils.ts
@@ -1,3 +1,29 @@
+import { matchSorter } from "match-sorter";
+import type { AllowedFileExtension } from "@webstudio-is/sdk";
+import {
+ acceptToMimePatterns,
+ doesAssetMatchMimePatterns,
+} from "@webstudio-is/sdk";
+import type { Asset } from "@webstudio-is/sdk";
+import type { AssetContainer } from "../assets";
+
+export type SortField = "name" | "size" | "createdAt";
+export type SortOrder = "asc" | "desc";
+
+export type SortState = {
+ sortBy: SortField;
+ order: SortOrder;
+};
+
+/**
+ * Safely gets the asset format as a lowercase extension.
+ */
+export const getAssetFormat = (
+ asset: Pick<Asset, "format">
+): AllowedFileExtension | undefined => {
+ return asset.format?.toLowerCase() as AllowedFileExtension | undefined;
+};
+
const gcd = (a: number, b: number): number => {
return b ? gcd(b, a % b) : a;
};
@@ -16,3 +42,124 @@ export const getFormattedAspectRatio = ({
return `${width / divisor}:${height / divisor}`;
};
+
+/**
+ * Sort asset containers by field and order
+ */
+export const sortAssets = (
+ assetContainers: AssetContainer[],
+ sortState: SortState
+): AssetContainer[] => {
+ const { sortBy, order } = sortState;
+ const sorted = [...assetContainers];
+
+ sorted.sort((a, b) => {
+ let comparison = 0;
+
+ if (sortBy === "name") {
+ const aName = a.asset.name.toLowerCase();
+ const bName = b.asset.name.toLowerCase();
+ comparison = aName.localeCompare(bName);
+ } else if (sortBy === "size") {
+ const aSize =
+ a.status === "uploaded" ? a.asset.size : Number.MAX_SAFE_INTEGER;
+ const bSize =
+ b.status === "uploaded" ? b.asset.size : Number.MAX_SAFE_INTEGER;
+ comparison = aSize - bSize;
+ } else if (sortBy === "createdAt") {
+ const aCreated = a.status === "uploaded" ? a.asset.createdAt || "" : "";
+ const bCreated = b.status === "uploaded" ? b.asset.createdAt || "" : "";
+ comparison = new Date(aCreated).getTime() - new Date(bCreated).getTime();
+ }
+
+ return order === "asc" ? comparison : -comparison;
+ });
+
+ return sorted;
+};
+
+/**
+ * Get initial selected extensions based on accept pattern
+ */
+export const getInitialExtensions = (
+ accept: string,
+ assetContainers: AssetContainer[]
+): AllowedFileExtension[] | "*" => {
+ const patterns = acceptToMimePatterns(accept);
+ if (patterns === "*") {
+ return "*";
+ }
+ const extensions: AllowedFileExtension[] = [];
+ assetContainers.forEach((container) => {
+ if (doesAssetMatchMimePatterns(container.asset, patterns)) {
+ const ext = getAssetFormat(container.asset);
+ if (ext !== undefined && !extensions.includes(ext)) {
+ extensions.push(ext);
+ }
+ }
+ });
+ return extensions.length > 0 ? extensions : "*";
+};
+
+/**
+ * Calculate format counts for all assets
+ */
+export const calculateFormatCounts = (
+ assetContainers: AssetContainer[]
+): Partial<Record<AllowedFileExtension, number>> => {
+ const counts: Partial<Record<AllowedFileExtension, number>> = {};
+ assetContainers.forEach((container) => {
+ const ext = getAssetFormat(container.asset);
+ if (ext !== undefined) {
+ counts[ext] = (counts[ext] || 0) + 1;
+ }
+ });
+ return counts;
+};
+
+/**
+ * Filter and sort asset containers
+ */
+export const filterAndSortAssets = ({
+ assetContainers,
+ selectedExtensions,
+ searchQuery,
+ sortState,
+}: {
+ assetContainers: AssetContainer[];
+ selectedExtensions: AllowedFileExtension[] | "*";
+ searchQuery: string;
+ sortState: SortState;
+}): AssetContainer[] => {
+ // Filter by selected extensions
+ let filtered = assetContainers;
+ if (selectedExtensions !== "*") {
+ filtered = assetContainers.filter((item) => {
+ const ext = getAssetFormat(item.asset);
+ return ext !== undefined && selectedExtensions.includes(ext);
+ });
+ }
+
+ // Apply search
+ if (searchQuery !== "") {
+ filtered = matchSorter(filtered, searchQuery, {
+ keys: [(item) => item.asset.name],
+ });
+ }
+
+ // Apply sorting
+ return sortAssets(filtered, sortState);
+};
+
+/**
+ * Find index of asset container by asset id
+ */
+export const findAssetIndex = (
+ assetContainers: AssetContainer[],
+ assetId?: string
+): number => {
+ if (assetId === undefined) {
+ return -1;
+ }
+ return assetContainers.findIndex((item) => item.asset.id === assetId);
+};
diff --git a/apps/builder/app/builder/shared/assets/asset-utils.test.ts b/apps/builder/app/builder/shared/assets/asset-utils.test.ts
index 91d1c6d543..8f37e7ee56 100644
--- a/apps/builder/app/builder/shared/assets/asset-utils.test.ts
+++ b/apps/builder/app/builder/shared/assets/asset-utils.test.ts
@@ -5,6 +5,7 @@ import {
getImageNameAndType,
getSha256Hash,
detectAssetType,
+ uploadingFileDataToAsset,
} from "./asset-utils";
import type { Asset } from "@webstudio-is/sdk";
@@ -190,3 +191,145 @@ describe("detectAssetType", () => {
expect(detectAssetType("my.doc.file.pdf")).toBe("file");
});
});
+
+describe("uploadingFileDataToAsset", () => {
+ test("extracts format from MIME type for font with valid MIME", () => {
+ const file = new File(["content"], "InterVariable.woff2", {
+ type: "font/woff2",
+ });
+ const result = uploadingFileDataToAsset({
+ source: "file",
+ file,
+ assetId: "test-id",
+ type: "font",
+ objectURL: "blob:test",
+ });
+
+ expect(result).toMatchObject({
+ id: "test-id",
+ name: "InterVariable.woff2",
+ format: "woff2",
+ type: "font",
+ });
+ });
+
+ test("falls back to filename extension when MIME type is missing", () => {
+ const file = new File(["content"], "InterVariable.woff2", {
+ type: "", // Empty MIME type
+ });
+ const result = uploadingFileDataToAsset({
+ source: "file",
+ file,
+ assetId: "test-id",
+ type: "font",
+ objectURL: "blob:test",
+ });
+
+ expect(result).toMatchObject({
+ id: "test-id",
+ name: "InterVariable.woff2",
+ format: "woff2",
+ type: "font",
+ });
+ });
+
+ test("handles image files with valid MIME type", () => {
+ const file = new File(["content"], "photo.jpg", {
+ type: "image/jpeg",
+ });
+ const result = uploadingFileDataToAsset({
+ source: "file",
+ file,
+ assetId: "test-id",
+ type: "image",
+ objectURL: "blob:test",
+ });
+
+ expect(result).toMatchObject({
+ id: "test-id",
+ name: "photo.jpg",
+ format: "jpeg",
+ type: "image",
+ });
+ });
+
+ test("handles video files", () => {
+ const file = new File(["content"], "video.mp4", {
+ type: "video/mp4",
+ });
+ const result = uploadingFileDataToAsset({
+ source: "file",
+ file,
+ assetId: "test-id",
+ type: "video",
+ objectURL: "blob:test",
+ });
+
+ expect(result).toMatchObject({
+ id: "test-id",
+ name: "video.mp4",
+ format: "mp4",
+ type: "image", // Videos are treated as images for now
+ });
+ });
+
+ test("handles generic file types", () => {
+ const file = new File(["content"], "document.pdf", {
+ type: "application/pdf",
+ });
+ const result = uploadingFileDataToAsset({
+ source: "file",
+ file,
+ assetId: "test-id",
+ type: "file",
+ objectURL: "blob:test",
+ });
+
+ expect(result).toMatchObject({
+ id: "test-id",
+ name: "document.pdf",
+ format: "pdf",
+ type: "file",
+ });
+ });
+
+ test("extracts format from filename when MIME type has no subtype", () => {
+ const file = new File(["content"], "font.ttf", {
+ type: "font",
+ });
+ const result = uploadingFileDataToAsset({
+ source: "file",
+ file,
+ assetId: "test-id",
+ type: "font",
+ objectURL: "blob:test",
+ });
+
+ expect(result).toMatchObject({
+ id: "test-id",
+ name: "font.ttf",
+ format: "ttf",
+ type: "font",
+ });
+ });
+
+ test("handles files with no extension", () => {
+ const file = new File(["content"], "README", {
+ type: "",
+ });
+ const result = uploadingFileDataToAsset({
+ source: "file",
+ file,
+ assetId: "test-id",
+ type: "file",
+ objectURL: "blob:test",
+ });
+
+ expect(result).toMatchObject({
+ id: "test-id",
+ name: "README",
+ format: "",
+ type: "file",
+ });
+ });
+});
diff --git a/apps/builder/app/builder/shared/assets/asset-utils.ts b/apps/builder/app/builder/shared/assets/asset-utils.ts
index 3862e75f5f..7000b21d5d 100644
--- a/apps/builder/app/builder/shared/assets/asset-utils.ts
+++ b/apps/builder/app/builder/shared/assets/asset-utils.ts
@@ -106,7 +106,15 @@ export const uploadingFileDataToAsset = (
fileData.source === "file" ? fileData.file : new URL(fileData.url);
const fileName = getFileName(fileOrUrl);
const mimeType = getMimeType(fileOrUrl);
- const format = mimeType.split("/")[1];
+
+ // Extract format from MIME type if available, otherwise from filename extension
+ let format = mimeType.split("/")[1];
+ if (!format) {
+ // Fallback to file extension if MIME type doesn't provide format
+ const match = fileName.match(/\.([^.]+)$/);
+ format = match ? match[1].toLowerCase() : "";
+ }
+
const assetType = detectAssetType(fileName);
if (assetType === "video") {