@payloadcms/figma 0.1.0-alpha.4 → 0.1.0-alpha.5

package/dist/plugin/cloud-limits/shared.js

@@ -7,6 +7,20 @@ const knownCloudLimitCodes = Object.values(cloudLimitErrorCodes);
 export function isCloudLimitErrorCode(code) {
     return typeof code === 'string' && knownCloudLimitCodes.includes(code);
 }
+const cloudLimitCodeByMessagePattern = [
+    {
+        code: cloudLimitErrorCodes.documentCount,
+        pattern: /document count/i
+    },
+    {
+        code: cloudLimitErrorCodes.documentDataSize,
+        pattern: /document data size/i
+    },
+    {
+        code: cloudLimitErrorCodes.assetStorage,
+        pattern: /asset storage limit/i
+    }
+];
 export function getCloudLimitErrorCode(json) {
     const errors = json?.errors;
     if (!Array.isArray(errors)) {
@@ -17,11 +31,22 @@ export function getCloudLimitErrorCode(json) {
         if (isCloudLimitErrorCode(code)) {
             return code;
         }
+        const message = err?.message;
+        if (message?.startsWith('Content API ')) {
+            // Payload's bulk-upload response currently drops APIError.data.code. Match only the
+            // identifying phrase from each Content API message so variable values and minor wording
+            // changes do not break the fallback. Prefer the structured code above whenever present.
+            const match = cloudLimitCodeByMessagePattern.find(({ pattern })=>pattern.test(message));
+            if (match) {
+                return match.code;
+            }
+        }
     }
     return undefined;
 }
 export const cloudLimitDocumentCountModalSlug = 'figma-cloud-limit-document-count';
 export const cloudLimitToastKeyByCode = {
     [cloudLimitErrorCodes.assetStorage]: 'figma:cloudLimitAssetStorageError',
+    [cloudLimitErrorCodes.documentCount]: 'figma:cloudLimitDocumentCountError',
     [cloudLimitErrorCodes.documentDataSize]: 'figma:cloudLimitDocumentDataSizeError'
 };

package/dist/plugin/cloud-limits/utilities/cloudLimitInterceptor.d.ts

@@ -0,0 +1,2 @@
+import type { Translate } from './toasts.js';
+export declare function cloudLimitInterceptor(apiRoute: string, translate: Translate): () => void;

package/dist/plugin/cloud-limits/utilities/cloudLimitInterceptor.js

@@ -0,0 +1,134 @@
+'use client';
+import { toast } from '@payloadcms/ui';
+import { formatAdminURL } from 'payload/shared';
+import { getCloudLimitErrorCode } from '../shared.js';
+import { showCloudLimitToast } from './toasts.js';
+const ERROR_SUPPRESSION_MS = 1_000;
+const SUMMARY_SUPPRESSION_MS = 60_000;
+function restoreBulkErrorCodes(response, json) {
+    if (!json || typeof json !== 'object' || !Array.isArray(json.docs) || !Array.isArray(json.errors)) {
+        return undefined;
+    }
+    let hasLimitError = false;
+    const errors = json.errors.map((error)=>{
+        const code = getCloudLimitErrorCode({
+            errors: [
+                error
+            ]
+        });
+        if (!code || !error || typeof error !== 'object') {
+            return error;
+        }
+        hasLimitError = true;
+        const data = error.data;
+        return {
+            ...error,
+            data: {
+                ...typeof data === 'object' && data ? data : {},
+                code
+            }
+        };
+    });
+    if (!hasLimitError) {
+        return undefined;
+    }
+    const { message: _aggregateMessage, ...result } = json;
+    const headers = new Headers(response.headers);
+    headers.delete('content-encoding');
+    headers.delete('content-length');
+    return new Response(JSON.stringify({
+        ...result,
+        errors
+    }), {
+        headers,
+        status: response.status,
+        statusText: response.statusText
+    });
+}
+export function cloudLimitInterceptor(apiRoute, translate) {
+    const originalFetch = window.fetch;
+    const originalToastError = toast.error;
+    const suppressions = new Map();
+    let suppressSummary = false;
+    let summaryTimeout;
+    const patchedToastError = (...args)=>{
+        const message = typeof args[0] === 'string' ? args[0] : args[0]?.props?.errorMessage ?? '';
+        const match = [
+            ...suppressions
+        ].find(([rawMessage])=>message.includes(rawMessage));
+        if (match) {
+            const [, suppression] = match;
+            // Keep the suppression for its full lifetime so overlapping requests with the same raw
+            // error cannot leak duplicate Payload error toasts. The stable info-toast ID deduplicates
+            // the replacement notification.
+            showCloudLimitToast(suppression.code, translate);
+            if (suppression.isBulkUpload) {
+                suppressSummary = true;
+                window.clearTimeout(summaryTimeout);
+                summaryTimeout = window.setTimeout(()=>suppressSummary = false, SUMMARY_SUPPRESSION_MS);
+            }
+            return '';
+        }
+        if (suppressSummary && /^Failed to save \d+ files$/.test(message)) {
+            suppressSummary = false;
+            window.clearTimeout(summaryTimeout);
+            return '';
+        }
+        return originalToastError(...args);
+    };
+    const patchedFetch = async (...args)=>{
+        const response = await originalFetch(...args);
+        if (response.status < 400) {
+            return response;
+        }
+        try {
+            const json = await response.clone().json();
+            const bulkResponse = response.status === 400 ? restoreBulkErrorCodes(response, json) : undefined;
+            if (bulkResponse) {
+                return bulkResponse;
+            }
+            const input = args[0];
+            const pathname = new URL(input instanceof Request ? input.url : String(input), window.location.origin).pathname;
+            const method = (input instanceof Request ? input.method : args[1]?.method ?? 'GET').toUpperCase();
+            const apiPath = formatAdminURL({
+                apiRoute,
+                path: ''
+            }).replace(/\/$/, '');
+            const endpoint = pathname.startsWith(`${apiPath}/`) ? pathname.slice(apiPath.length + 1) : '';
+            const isUploadInstructions = endpoint === 'upload-instructions';
+            const isCollectionCreate = method === 'POST' && endpoint !== '' && !endpoint.includes('/');
+            if (!isUploadInstructions && !isCollectionCreate) {
+                return response;
+            }
+            const code = getCloudLimitErrorCode(json);
+            const rawMessage = json?.errors?.[0]?.message;
+            if (code && rawMessage) {
+                const previous = suppressions.get(rawMessage);
+                window.clearTimeout(previous?.timeout);
+                const suppression = {
+                    code,
+                    isBulkUpload: isCollectionCreate,
+                    timeout: 0
+                };
+                suppression.timeout = window.setTimeout(()=>suppressions.delete(rawMessage), ERROR_SUPPRESSION_MS);
+                suppressions.set(rawMessage, suppression);
+            }
+        } catch  {
+        // Leave Payload's default handling intact for malformed error responses.
+        }
+        return response;
+    };
+    window.fetch = patchedFetch;
+    toast.error = patchedToastError;
+    return ()=>{
+        suppressions.forEach(({ timeout })=>window.clearTimeout(timeout));
+        window.clearTimeout(summaryTimeout);
+        if (window.fetch === patchedFetch) {
+            window.fetch = originalFetch;
+        }
+        if (toast.error === patchedToastError) {
+            ;
+            toast.error = originalToastError;
+        }
+    };
+}

package/dist/plugin/cloud-limits/utilities/toasts.d.ts

@@ -0,0 +1,4 @@
+import type { CloudLimitErrorCode } from '../shared.js';
+export type Translate = (key: string) => string;
+export declare function dismissSubmittingToast(label: string): void;
+export declare function showCloudLimitToast(code: CloudLimitErrorCode, translate: Translate): void;

package/dist/plugin/cloud-limits/utilities/toasts.js

@@ -0,0 +1,19 @@
+'use client';
+import { toast } from '@payloadcms/ui';
+import { cloudLimitToastKeyByCode } from '../shared.js';
+const TOAST_ID_PREFIX = 'figma-cloud-limit';
+export function dismissSubmittingToast(label) {
+    const activeToasts = toast.getToasts();
+    for(let index = activeToasts.length - 1; index >= 0; index--){
+        const candidate = activeToasts[index];
+        if (candidate && !('dismiss' in candidate) && candidate.promise !== undefined && candidate.title === label && candidate.type === 'loading') {
+            toast.dismiss(candidate.id);
+            return;
+        }
+    }
+}
+export function showCloudLimitToast(code, translate) {
+    toast.info(translate(cloudLimitToastKeyByCode[code]), {
+        id: `${TOAST_ID_PREFIX}-${code}`
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/figma",
-  "version": "0.1.0-alpha.4",
+  "version": "0.1.0-alpha.5",
   "license": "SEE LICENSE IN LICENSE.md",
   "type": "module",
   "exports": {
@@ -13,6 +13,11 @@
       "import": "./dist/exports/client.js",
       "types": "./dist/exports/client.d.ts",
       "default": "./dist/exports/client.js"
+    },
+    "./views": {
+      "import": "./dist/exports/views.js",
+      "types": "./dist/exports/views.d.ts",
+      "default": "./dist/exports/views.js"
     }
   },
   "main": "./dist/index.js",
@@ -28,6 +33,7 @@
   ],
   "dependencies": {
     "@clack/prompts": "^0.11.0",
+    "@cloudflare/workers-types": "5.20260716.1",
     "@figma/rest-api-spec": "^0.34.0",
     "@sindresorhus/slugify": "^3.0.0",
     "archiver": "7.0.1",
@@ -105,6 +111,7 @@
     "test:int:watch": "TEST_INT=true vitest --config vitest.config.int.ts",
     "test:e2e": "TEST_E2E=true vitest run --config vitest.config.e2e.ts",
     "test:e2e:watch": "TEST_E2E=true vitest --config vitest.config.e2e.ts",
+    "test:types": "tsc --project tsconfig.imageSizeOptions.json",
     "test:watch": "TEST_UNIT=true vitest"
   }
 }

package/dist/db-content-api/utilities/data/stringifyNumericIds.d.ts

@@ -1 +0,0 @@
-export declare function stringifyNumericIds(value: unknown): unknown;

package/dist/db-content-api/utilities/data/stringifyNumericIds.js

@@ -1,19 +0,0 @@
-// The Content API stores every document id as a string, but Payload keeps a
-// collection's custom numeric id as a `number`. Stringify numbers so an id filter
-// matches the stored value.
-// Has two shapes it accepts:
-// - Scalar values (most operators)
-// - Arrays of values (for `in`/`not_in` operators)
-// Non-numeric entries (already-string ids) pass through untouched.
-export function stringifyNumericIds(value) {
-    if (typeof value === 'number') {
-        return stringifyNumericId(value);
-    }
-    if (Array.isArray(value)) {
-        return value.map((entry)=>stringifyNumericId(entry));
-    }
-    return value;
-}
-function stringifyNumericId(value) {
-    return typeof value === 'number' ? String(value) : value;
-}