@payloadcms/figma 0.0.1-alpha.58 → 0.0.1-alpha.59

package/dist/utils/adapters/vite.js

@@ -0,0 +1,32 @@
+import path from 'path';
+import { collectFilesRecursive } from '../fs-utils.js';
+export class ViteAdapter {
+    fallback = '/index.html';
+    name = 'vite';
+    async collectAssets(projectPath) {
+        const distDir = path.join(projectPath, 'dist');
+        const files = await collectFilesRecursive(distDir, distDir);
+        const pathMap = {};
+        for (const file of files){
+            pathMap[file] = path.join('dist', file);
+        }
+        return {
+            pathMap,
+            routes: files.map((k)=>`/${k}`),
+            uploadKeys: files
+        };
+    }
+    collectPages() {
+        return Promise.resolve({
+            pathMap: {},
+            routes: [],
+            uploadKeys: []
+        });
+    }
+    prepareLambdaBundle() {
+        return Promise.resolve(null);
+    }
+}
+export const viteAdapter = new ViteAdapter();
+
+//# sourceMappingURL=vite.js.map

package/dist/utils/asset-collection.d.ts

@@ -15,6 +15,30 @@ export declare function getFileSize(filePath: string): Promise<number>;
  * @returns Array of static asset paths (using _next prefix)
  */
 export declare function collectStaticAssets(projectPath: string): Promise<string[]>;
+/**
+ * Result from collecting SSG assets
+ */
+export type SSGAssets = {
+    /** S3 keys for all SSG files (route-path based, no leading slash) */
+    keys: string[];
+    /** Map of S3 key → relative filesystem path from project root */
+    pathMap: Record<string, string>;
+};
+/**
+ * Collect SSG asset paths by parsing .next/prerender-manifest.json
+ *
+ * For each route in the manifest's `routes` object, collects three files:
+ * - {route}.html  (full HTML)
+ * - {route}.rsc   (React Server Components payload)
+ * - {route}.meta  (response headers JSON)
+ *
+ * S3 keys use the route path without leading slash.
+ * Filesystem paths point to .next/server/app/{route}.{ext}
+ *
+ * @param projectPath - Path to project root
+ * @returns SSG asset keys and a pathMap for filesystem resolution
+ */
+export declare function collectSSGAssets(projectPath: string): Promise<SSGAssets>;
 /**
  * Create Lambda deployment zip
  *

package/dist/utils/asset-collection.js

@@ -79,6 +79,59 @@ const MAX_ASSET_SIZE = 50 * 1024 * 1024 // 50MB
         return normalized.replace(/^\.next\//, '_next/');
     });
 }
+/**
+ * Collect SSG asset paths by parsing .next/prerender-manifest.json
+ *
+ * For each route in the manifest's `routes` object, collects three files:
+ * - {route}.html  (full HTML)
+ * - {route}.rsc   (React Server Components payload)
+ * - {route}.meta  (response headers JSON)
+ *
+ * S3 keys use the route path without leading slash.
+ * Filesystem paths point to .next/server/app/{route}.{ext}
+ *
+ * @param projectPath - Path to project root
+ * @returns SSG asset keys and a pathMap for filesystem resolution
+ */ export async function collectSSGAssets(projectPath) {
+    const manifestPath = path.join(projectPath, '.next', 'prerender-manifest.json');
+    let manifest;
+    try {
+        const raw = await fs.readFile(manifestPath, 'utf-8');
+        manifest = JSON.parse(raw);
+    } catch  {
+        return {
+            keys: [],
+            pathMap: {}
+        };
+    }
+    if (!manifest.routes || typeof manifest.routes !== 'object') {
+        return {
+            keys: [],
+            pathMap: {}
+        };
+    }
+    const keys = [];
+    const pathMap = {};
+    const extensions = [
+        '.html',
+        '.rsc',
+        '.meta'
+    ];
+    for (const routeKey of Object.keys(manifest.routes)){
+        // Strip leading slash for S3 key; handle root "/" → "index"
+        const stripped = routeKey === '/' ? 'index' : routeKey.replace(/^\//, '');
+        for (const ext of extensions){
+            const s3Key = `${stripped}${ext}`;
+            const fsPath = path.join('.next', 'server', 'app', `${stripped}${ext}`);
+            keys.push(s3Key);
+            pathMap[s3Key] = fsPath;
+        }
+    }
+    return {
+        keys,
+        pathMap
+    };
+}
 /**
  * Create Lambda deployment zip
  *

package/dist/utils/build-detection.d.ts

@@ -2,24 +2,18 @@
  * Information about a detected build
  */
 export interface BuildInfo {
-    /** Build ID from .next/BUILD_ID */
+    /** Build identifier */
     buildId: string;
     /** Whether lambda.zip already exists */
     hasLambdaZip: boolean;
-    /** Path to .next/standalone */
+    /** Path to build output directory */
     path: string;
-    /** Build timestamp from server.js mtime */
+    /** Build timestamp */
     timestamp: Date;
 }
 /**
- * Detect if a valid Lambda-ready build exists
- *
- * Checks for:
- * - .next/standalone/server.js (required for Lambda)
- * - .next/BUILD_ID (Next.js build identifier)
- *
- * @param projectPath - Path to project root
- * @returns Build info if valid build found, null otherwise
+ * Detect a valid build across supported frameworks.
+ * Tries NextJS, then Nitro, then Vite. Returns the first match.
  */
 export declare function detectBuild(projectPath: string): Promise<BuildInfo | null>;
 /**

package/dist/utils/build-detection.js

@@ -1,23 +1,34 @@
 import fs from 'fs/promises';
 import path from 'path';
 /**
- * Detect if a valid Lambda-ready build exists
- *
- * Checks for:
- * - .next/standalone/server.js (required for Lambda)
- * - .next/BUILD_ID (Next.js build identifier)
- *
- * @param projectPath - Path to project root
- * @returns Build info if valid build found, null otherwise
+ * Detect a valid build across supported frameworks.
+ * Tries NextJS, then Nitro, then Vite. Returns the first match.
  */ export async function detectBuild(projectPath) {
+    // Try NextJS first
+    const nextjsBuild = await detectNextjsBuild(projectPath);
+    if (nextjsBuild) {
+        return nextjsBuild;
+    }
+    // Try Nitro
+    const nitroBuild = await detectNitroBuild(projectPath);
+    if (nitroBuild) {
+        return nitroBuild;
+    }
+    // Try Vite
+    const viteBuild = await detectViteBuild(projectPath);
+    if (viteBuild) {
+        return viteBuild;
+    }
+    return null;
+}
+/**
+ * Detect NextJS standalone build (.next/standalone/server.js + .next/BUILD_ID)
+ */ async function detectNextjsBuild(projectPath) {
     try {
-        // Check for .next/standalone/server.js
         const serverPath = path.join(projectPath, '.next', 'standalone', 'server.js');
         const serverStat = await fs.stat(serverPath);
-        // Check for .next/BUILD_ID
         const buildIdPath = path.join(projectPath, '.next', 'BUILD_ID');
         const buildId = (await fs.readFile(buildIdPath, 'utf-8')).trim();
-        // Check for lambda.zip
         const lambdaZipPath = path.join(projectPath, 'lambda.zip');
         let hasLambdaZip = false;
         try {
@@ -36,6 +47,58 @@ import path from 'path';
         return null;
     }
 }
+/**
+ * Detect Nitro build (.output/server/index.mjs)
+ * Build ID parsed from .output/nitro.json date field, or mtime of index.mjs
+ */ async function detectNitroBuild(projectPath) {
+    try {
+        const indexPath = path.join(projectPath, '.output', 'server', 'index.mjs');
+        const indexStat = await fs.stat(indexPath);
+        let buildId = indexStat.mtime.toISOString();
+        try {
+            const nitroJsonPath = path.join(projectPath, '.output', 'nitro.json');
+            const nitroJson = JSON.parse(await fs.readFile(nitroJsonPath, 'utf-8'));
+            if (nitroJson.date) {
+                buildId = nitroJson.date;
+            }
+        } catch  {
+        // nitro.json missing or unparseable — fall back to mtime
+        }
+        const lambdaZipPath = path.join(projectPath, 'lambda.zip');
+        let hasLambdaZip = false;
+        try {
+            await fs.stat(lambdaZipPath);
+            hasLambdaZip = true;
+        } catch  {
+            hasLambdaZip = false;
+        }
+        return {
+            buildId,
+            hasLambdaZip,
+            path: '.output',
+            timestamp: indexStat.mtime
+        };
+    } catch  {
+        return null;
+    }
+}
+/**
+ * Detect Vite build (dist/index.html)
+ * Build ID is mtime of index.html as ISO string. No server, so hasLambdaZip is always false.
+ */ async function detectViteBuild(projectPath) {
+    try {
+        const indexPath = path.join(projectPath, 'dist', 'index.html');
+        const indexStat = await fs.stat(indexPath);
+        return {
+            buildId: indexStat.mtime.toISOString(),
+            hasLambdaZip: false,
+            path: 'dist',
+            timestamp: indexStat.mtime
+        };
+    } catch  {
+        return null;
+    }
+}
 /**
  * Get the build command from package.json
  *

package/dist/utils/deploy-adapter.d.ts

@@ -0,0 +1,38 @@
+export interface PageCollection {
+    /** S3 key → relative filesystem path from project root */
+    pathMap: Record<string, string>;
+    /** Route paths for the manifest pages array (e.g., ["/products", "/blog"]) */
+    routes: string[];
+    /** S3 keys to upload (e.g., ["products.html", "products.rsc", "products.meta"]) */
+    uploadKeys: string[];
+}
+export interface AssetCollection {
+    /** S3 key → relative filesystem path from project root */
+    pathMap: Record<string, string>;
+    /** Route paths for the manifest assets array (e.g., ["/favicon.ico"]) */
+    routes: string[];
+    /** S3 keys to upload (same as routes for assets, without leading slash) */
+    uploadKeys: string[];
+}
+export type AdapterName = 'nextjs' | 'nitro' | 'vite';
+export interface DeployAdapter {
+    collectAssets(projectPath: string): Promise<AssetCollection>;
+    collectPages(projectPath: string): Promise<PageCollection>;
+    /** SPA fallback path (e.g., "/index.html"). Undefined for SSR/SSG apps. */
+    fallback?: string;
+    name: AdapterName;
+    /** Assembles and zips the server bundle. Returns path to zip, or null if no server (e.g., Vite SPA). */
+    prepareLambdaBundle(projectPath: string): Promise<null | string>;
+}
+/**
+ * Auto-detect the framework adapter based on build output.
+ *
+ * - .next/ exists → nextjs
+ * - .output/nitro.json exists → nitro
+ * - dist/index.html exists (no .next/, no .output/) → vite
+ *
+ * @param projectPath - Path to project root
+ * @param override - Explicit adapter name from --adapter flag
+ */
+export declare function detectAdapter(projectPath: string, override?: AdapterName): Promise<DeployAdapter>;
+//# sourceMappingURL=deploy-adapter.d.ts.map

package/dist/utils/deploy-adapter.js

@@ -0,0 +1,58 @@
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * Auto-detect the framework adapter based on build output.
+ *
+ * - .next/ exists → nextjs
+ * - .output/nitro.json exists → nitro
+ * - dist/index.html exists (no .next/, no .output/) → vite
+ *
+ * @param projectPath - Path to project root
+ * @param override - Explicit adapter name from --adapter flag
+ */ export async function detectAdapter(projectPath, override) {
+    if (override) {
+        return loadAdapter(override);
+    }
+    const hasNext = await exists(path.join(projectPath, '.next'));
+    const hasNitro = await exists(path.join(projectPath, '.output', 'nitro.json'));
+    const hasViteDist = await exists(path.join(projectPath, 'dist', 'index.html'));
+    if (hasNext) {
+        return loadAdapter('nextjs');
+    }
+    if (hasNitro) {
+        return loadAdapter('nitro');
+    }
+    if (hasViteDist) {
+        return loadAdapter('vite');
+    }
+    throw new Error('Could not detect framework. Expected .next/ (NextJS), .output/nitro.json (Nitro), or dist/index.html (Vite). ' + 'Use --adapter to specify explicitly.');
+}
+async function loadAdapter(name) {
+    switch(name){
+        case 'nextjs':
+            {
+                const mod = await import('./adapters/nextjs.js');
+                return mod.nextjsAdapter;
+            }
+        case 'nitro':
+            {
+                const mod = await import('./adapters/nitro.js');
+                return mod.nitroAdapter;
+            }
+        case 'vite':
+            {
+                const mod = await import('./adapters/vite.js');
+                return mod.viteAdapter;
+            }
+    }
+}
+async function exists(filePath) {
+    try {
+        await fs.stat(filePath);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+
+//# sourceMappingURL=deploy-adapter.js.map

package/dist/utils/fs-utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Recursively collect all file paths under a directory,
+ * returned as forward-slash-separated paths relative to baseDir.
+ */
+export declare function collectFilesRecursive(dir: string, baseDir: string): Promise<string[]>;
+//# sourceMappingURL=fs-utils.d.ts.map

package/dist/utils/fs-utils.js

@@ -0,0 +1,27 @@
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * Recursively collect all file paths under a directory,
+ * returned as forward-slash-separated paths relative to baseDir.
+ */ export async function collectFilesRecursive(dir, baseDir) {
+    const files = [];
+    try {
+        const entries = await fs.readdir(dir, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                const subFiles = await collectFilesRecursive(fullPath, baseDir);
+                files.push(...subFiles);
+            } else if (entry.isFile()) {
+                files.push(path.relative(baseDir, fullPath).split(path.sep).join('/'));
+            }
+        }
+    } catch  {
+    // Not accessible
+    }
+    return files;
+}
+
+//# sourceMappingURL=fs-utils.js.map

package/dist/utils/s3-upload.d.ts

@@ -38,5 +38,11 @@ export declare function uploadLambdaZip(zipPath: string, signedUrl: string): Pro
  * @param onProgress - Optional callback for progress updates (uploaded, total)
  * @returns Upload results with counts
  */
-export declare function uploadStaticAssets(projectPath: string, assetUrls: Record<string, string>, onProgress?: (uploaded: number, total: number) => void): Promise<UploadResults>;
+export declare function uploadStaticAssets(params: {
+    assetUrls: Record<string, string>;
+    onProgress?: (uploaded: number, total: number) => void;
+    /** Map of S3 key → relative filesystem path (overrides default _next/ → .next/ resolution) */
+    pathMap?: Record<string, string>;
+    projectPath: string;
+}): Promise<UploadResults>;
 //# sourceMappingURL=s3-upload.d.ts.map

package/dist/utils/s3-upload.js

@@ -90,7 +90,8 @@ const INITIAL_RETRY_DELAY = 1000 // 1 second
  * @param assetUrls - Map of asset paths to signed URLs
  * @param onProgress - Optional callback for progress updates (uploaded, total)
  * @returns Upload results with counts
- */ export async function uploadStaticAssets(projectPath, assetUrls, onProgress) {
+ */ export async function uploadStaticAssets(params) {
+    const { assetUrls, onProgress, pathMap, projectPath } = params;
     const results = {
         assetsFailed: 0,
         assetsUploaded: 0,
@@ -107,8 +108,8 @@ const INITIAL_RETRY_DELAY = 1000 // 1 second
         const batch = assetPaths.slice(i, i + CONCURRENCY);
         await Promise.all(batch.map(async (assetPath)=>{
             try {
-                // Convert _next back to .next for file system
-                const fsPath = assetPath.replace(/^_next\//, '.next/');
+                // Resolve filesystem path: use pathMap if available, else default _next/ → .next/
+                const fsPath = pathMap?.[assetPath] ?? assetPath.replace(/^_next\//, '.next/');
                 const fullPath = path.join(projectPath, fsPath);
                 const signedUrl = assetUrls[assetPath];
                 await uploadFile(fullPath, signedUrl);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/figma",
-  "version": "0.0.1-alpha.58",
+  "version": "0.0.1-alpha.59",
   "license": "SEE LICENSE IN LICENSE.md",
   "type": "module",
   "exports": {