@payloadcms/figma 0.1.0-alpha.7 → 0.1.0-alpha.9

package/dist/utils/build-lambda-zip.js

@@ -1,10 +1,11 @@
 import archiver from 'archiver';
 import { createWriteStream } from 'fs';
-import fs from 'fs/promises';
 import path from 'path';
+import { configureNextjsCache } from './configureNextjsCache.js';
 import { inspectNextjsOutput } from './deploy-output/inspectNextjsOutput.js';
 import { resolveOutputPath } from './deploy-output/resolveOutputPath.js';
-import { getDirectorySize } from './fs-utils.js';
+import { walkBundleFiles } from './fs-utils.js';
+import { isBundlableFile } from './secret-files.js';
 /**
  * AWS Lambda's hard limit on unzipped deployment code size (250 MB). The unzipped
  * total must be strictly less than this value, so a bundle exactly equal to it is
@@ -31,17 +32,43 @@ import { getDirectorySize } from './fs-utils.js';
     if (!layout) {
         throw new Error(`Standalone build not found at ${outputPath}`);
     }
-    const serverEntry = path.relative(layout.standalonePath, layout.serverEntryPath).split(path.sep).join('/');
-    const runScript = createRunScript(serverEntry);
+    const files = (await walkBundleFiles(layout.standalonePath)).filter((file)=>isBundlableFile(file.relativePath));
+    // Override archive entries in memory without changing Next's standalone output.
+    const bundleFileOverrides = await createBundleFileOverrides(layout.standalonePath, layout.serverEntryPath);
     const zipPath = path.join(projectPath, 'lambda.zip');
-    const existingRunScriptBytes = await getFileSize(path.join(layout.standalonePath, 'run.sh'));
-    const unzippedBytes = await getDirectorySize(layout.standalonePath) - existingRunScriptBytes + Buffer.byteLength(runScript);
-    await createZip(layout.standalonePath, zipPath, runScript);
+    let unzippedBytes = files.reduce((total, file)=>total + file.size, 0);
+    for (const [name, contents] of bundleFileOverrides){
+        const existingBytes = files.find((file)=>file.relativePath === name)?.size ?? 0;
+        unzippedBytes += contents.byteLength - existingBytes;
+    }
+    await createZip(files, zipPath, bundleFileOverrides);
     return {
         unzippedBytes,
         zipPath
     };
 }
+/**
+ * Returns files that replace or extend the standalone output in the Lambda zip:
+ * the generated launcher, the cache-configured server entry, and its optional
+ * cache handler. All paths are relative to the zip root.
+ */ async function createBundleFileOverrides(standalonePath, serverEntryPath) {
+    const serverEntry = path.relative(standalonePath, serverEntryPath).split(path.sep).join('/');
+    const cacheConfiguration = await configureNextjsCache(serverEntryPath);
+    const bundleFileOverrides = new Map([
+        [
+            'run.sh',
+            Buffer.from(createRunScript(serverEntry))
+        ],
+        [
+            serverEntry,
+            Buffer.from(cacheConfiguration.server)
+        ]
+    ]);
+    if (cacheConfiguration.handler) {
+        bundleFileOverrides.set(path.posix.join(path.posix.dirname(serverEntry), cacheConfiguration.handler.name), cacheConfiguration.handler.data);
+    }
+    return bundleFileOverrides;
+}
 function createRunScript(serverEntry) {
     const escapedEntry = serverEntry.replaceAll("'", "'\\''");
     return `#!/bin/bash -x
@@ -49,10 +76,7 @@ function createRunScript(serverEntry) {
 NODE_ENV=production exec node '${escapedEntry}'
 `;
 }
-async function getFileSize(filePath) {
-    return fs.stat(filePath).then((stat)=>stat.isFile() ? stat.size : 0).catch(()=>0);
-}
-function createZip(sourceDir, zipPath, runScript) {
+function createZip(files, zipPath, bundleFileOverrides) {
     return new Promise((resolve, reject)=>{
         const output = createWriteStream(zipPath);
         const archive = archiver('zip', {
@@ -63,11 +87,20 @@ function createZip(sourceDir, zipPath, runScript) {
         output.on('close', ()=>resolve());
         archive.on('error', (err)=>reject(err));
         archive.pipe(output);
-        archive.directory(sourceDir, false, (entry)=>entry.name === 'run.sh' ? false : entry);
-        archive.append(runScript, {
-            name: 'run.sh',
-            mode: 0o755
-        });
+        for (const file of files){
+            if (bundleFileOverrides.has(file.relativePath)) {
+                continue;
+            }
+            archive.file(file.sourcePath, {
+                name: file.relativePath
+            });
+        }
+        for (const [name, contents] of bundleFileOverrides){
+            archive.append(contents, {
+                name,
+                mode: name === 'run.sh' ? 0o755 : 0o644
+            });
+        }
         void archive.finalize();
     });
 }

package/dist/utils/configureNextjsCache.d.ts

@@ -0,0 +1,7 @@
+export declare function configureNextjsCache(serverEntryPath: string): Promise<{
+    handler?: {
+        data: Buffer;
+        name: string;
+    };
+    server: string;
+}>;

package/dist/utils/configureNextjsCache.js

@@ -0,0 +1,55 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { Node, Project } from 'ts-morph';
+import { info } from './log.js';
+const CACHE_HANDLER_FILE = '__figma_nextjs_cache.mjs';
+export async function configureNextjsCache(serverEntryPath) {
+    const original = await fs.readFile(serverEntryPath, 'utf8');
+    const project = new Project({
+        useInMemoryFileSystem: true
+    });
+    const source = project.createSourceFile('server.js', original);
+    const initializer = source.getVariableDeclaration('nextConfig')?.getInitializer();
+    if (!initializer || !Node.isObjectLiteralExpression(initializer)) {
+        throw new Error('Unsupported Next.js standalone server: expected a nextConfig object');
+    }
+    // Only accept Next's generated JSON, not arbitrary application code.
+    let config;
+    try {
+        config = JSON.parse(initializer.getText());
+    } catch  {
+        throw new Error('Unsupported Next.js standalone server: expected generated JSON config');
+    }
+    const experimental = config.experimental;
+    // cacheHandler is the stable name; older Next.js builds use the experimental path.
+    if (config.cacheHandler || experimental?.incrementalCacheHandlerPath) {
+        info('Using the application cacheHandler; Figma fresh-only caching is not enabled.');
+        return {
+            server: original
+        };
+    }
+    const reservedPath = path.join(path.dirname(serverEntryPath), CACHE_HANDLER_FILE);
+    const exists = await fs.lstat(reservedPath).then(()=>true, (error)=>{
+        if (error.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    });
+    if (exists) {
+        throw new Error(`Standalone output contains reserved file ${CACHE_HANDLER_FILE}`);
+    }
+    initializer.getProperty('"cacheHandler"')?.remove();
+    initializer.addPropertyAssignments([
+        {
+            name: 'cacheHandler',
+            initializer: `require.resolve('./${CACHE_HANDLER_FILE}')`
+        }
+    ]);
+    return {
+        handler: {
+            name: CACHE_HANDLER_FILE,
+            data: await fs.readFile(new URL('./lambda-runtime/nextjs-cache.js', import.meta.url))
+        },
+        server: source.getFullText()
+    };
+}

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

@@ -3,10 +3,37 @@
  * returned as forward-slash-separated paths relative to baseDir.
  */
 export declare function collectFilesRecursive(dir: string, baseDir: string): Promise<string[]>;
+export declare class EscapingSymlinkError extends Error {
+    readonly symlinkPath: string;
+    readonly targetPath: string;
+    constructor(symlinkPath: string, targetPath: string, root: string);
+}
+export interface BundleFile {
+    /** Forward-slash path relative to the walk root; used as the zip entry name. */
+    relativePath: string;
+    /**
+     * Bytes this entry contributes to unzipped size. Regular files use content
+     * size; in-tree symlinks use `lstat` size (the stored link path).
+     */
+    size: number;
+    /** Path passed to the archiver; may be an in-tree symlink. */
+    sourcePath: string;
+}
 /**
- * Recursively sum the byte size of all files under a directory.
- * Returns 0 for a missing or unreadable directory. Symlinks are not
- * followed. Files that disappear or become unreadable between readdir
- * and stat are skipped (treated as 0 bytes).
+ * Recursively list files under `root` for Lambda bundle sizing and archiving.
+ *
+ * Regular files and directories are included. Symlinks are included (not
+ * followed) only when the resolved target stays within `root`; otherwise an
+ * {@link EscapingSymlinkError} is thrown. This matches `archiver.directory`,
+ * which stores zip symlink entries rather than copying target contents.
+ * Broken or unreadable files are skipped.
+ */
+export declare function walkBundleFiles(root: string): Promise<BundleFile[]>;
+/**
+ * Recursively sum the byte size of all files under a directory using the same
+ * symlink policy as {@link walkBundleFiles}. Returns 0 for a missing or
+ * unreadable directory. Escaping symlinks throw {@link EscapingSymlinkError}.
+ * Files that disappear or become unreadable between readdir and stat are
+ * skipped (treated as 0 bytes).
  */
 export declare function getDirectorySize(dir: string): Promise<number>;

package/dist/utils/fs-utils.js

@@ -23,33 +23,113 @@ import path from 'path';
     }
     return files;
 }
+export class EscapingSymlinkError extends Error {
+    symlinkPath;
+    targetPath;
+    constructor(symlinkPath, targetPath, root){
+        super(`Symlink '${symlinkPath}' points outside ${root} (${targetPath})`), this.symlinkPath = symlinkPath, this.targetPath = targetPath;
+        this.name = 'EscapingSymlinkError';
+    }
+}
+/**
+ * Recursively list files under `root` for Lambda bundle sizing and archiving.
+ *
+ * Regular files and directories are included. Symlinks are included (not
+ * followed) only when the resolved target stays within `root`; otherwise an
+ * {@link EscapingSymlinkError} is thrown. This matches `archiver.directory`,
+ * which stores zip symlink entries rather than copying target contents.
+ * Broken or unreadable files are skipped.
+ */ export async function walkBundleFiles(root) {
+    const rootReal = await fs.realpath(root);
+    const files = [];
+    await walkBundleDir(root, root, rootReal, files);
+    return files;
+}
 /**
- * Recursively sum the byte size of all files under a directory.
- * Returns 0 for a missing or unreadable directory. Symlinks are not
- * followed. Files that disappear or become unreadable between readdir
- * and stat are skipped (treated as 0 bytes).
+ * Recursively sum the byte size of all files under a directory using the same
+ * symlink policy as {@link walkBundleFiles}. Returns 0 for a missing or
+ * unreadable directory. Escaping symlinks throw {@link EscapingSymlinkError}.
+ * Files that disappear or become unreadable between readdir and stat are
+ * skipped (treated as 0 bytes).
  */ export async function getDirectorySize(dir) {
+    try {
+        const files = await walkBundleFiles(dir);
+        return files.reduce((total, file)=>total + file.size, 0);
+    } catch (error) {
+        if (error instanceof EscapingSymlinkError) {
+            throw error;
+        }
+        return 0;
+    }
+}
+function isPathWithin(rootReal, targetReal) {
+    const relative = path.relative(rootReal, targetReal);
+    return relative === '' || relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+async function walkBundleDir(dir, root, rootReal, files) {
     let entries;
     try {
         entries = await fs.readdir(dir, {
             withFileTypes: true
         });
     } catch  {
-        return 0;
+        return;
     }
-    let total = 0;
     for (const entry of entries){
         const fullPath = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            total += await getDirectorySize(fullPath);
+        if (entry.isSymbolicLink()) {
+            await addSymlinkEntry(fullPath, root, rootReal, files);
+        } else if (entry.isDirectory()) {
+            await walkBundleDir(fullPath, root, rootReal, files);
         } else if (entry.isFile()) {
-            try {
-                const stats = await fs.stat(fullPath);
-                total += stats.size;
-            } catch  {
-            // File vanished or is unreadable between readdir and stat — skip it.
-            }
+            await addRegularFile(fullPath, root, files);
+        }
+    }
+}
+async function addSymlinkEntry(fullPath, root, rootReal, files) {
+    const relativePath = toRelativePath(root, fullPath);
+    const targetPath = await resolveSymlinkTarget(fullPath);
+    if (targetPath === null) {
+        return;
+    }
+    if (!isPathWithin(rootReal, targetPath)) {
+        throw new EscapingSymlinkError(relativePath, targetPath, root);
+    }
+    try {
+        const stats = await fs.lstat(fullPath);
+        files.push({
+            relativePath,
+            size: stats.size,
+            sourcePath: fullPath
+        });
+    } catch  {
+    // Symlink vanished between readdir and lstat — skip it.
+    }
+}
+async function resolveSymlinkTarget(fullPath) {
+    try {
+        return await fs.realpath(fullPath);
+    } catch  {
+        try {
+            const link = await fs.readlink(fullPath);
+            return path.resolve(path.dirname(fullPath), link);
+        } catch  {
+            return null;
         }
     }
-    return total;
+}
+async function addRegularFile(fullPath, root, files) {
+    try {
+        const stats = await fs.stat(fullPath);
+        files.push({
+            relativePath: toRelativePath(root, fullPath),
+            size: stats.size,
+            sourcePath: fullPath
+        });
+    } catch  {
+    // File vanished or is unreadable between readdir and stat — skip it.
+    }
+}
+function toRelativePath(root, fullPath) {
+    return path.relative(root, fullPath).split(path.sep).join('/');
 }

package/dist/utils/lambda-config.js

@@ -1,6 +1,8 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { IndentationText, Node, Project, SyntaxKind } from 'ts-morph';
+import { addFigmaImageLoaderConfig } from './next-image-loader-config.js';
+import { writeFigmaImageLoaderFile } from './next-image-loader-file.js';
 import { ensurePnpmWorkspace } from './pnpm-builds.js';
 const RUN_SH_CONTENT = `#!/bin/bash -x
 
@@ -18,8 +20,9 @@ NODE_ENV=production exec node server.js
     const runShPath = path.join(projectPath, 'run.sh');
     await fs.writeFile(runShPath, RUN_SH_CONTENT, 'utf-8');
     await fs.chmod(runShPath, 0o755);
-    // 2. Modify next config to add standalone output
+    // 2. Add Next.js-specific configuration.
     await addNextConfigProperties(projectPath);
+    await writeFigmaImageLoaderFile(projectPath);
     // 3. Add lambda:buildzip script to package.json
     await addLambdaBuildScript(projectPath, packageManager);
     // 4. Write pnpm-workspace.yaml (hoisted linker + build approvals)
@@ -48,6 +51,7 @@ NODE_ENV=production exec node server.js
 /**
  * Add required Next.js config properties using ts-morph AST parsing
  * - output: 'standalone' (for Lambda deployment)
+ * - images.loader: 'custom' and images.loaderFile for Payload media
  */ async function addNextConfigProperties(projectPath) {
     const nextConfigPath = await findNextConfigPath(projectPath);
     const project = new Project({
@@ -65,15 +69,16 @@ NODE_ENV=production exec node server.js
     if (!configObject) {
         throw new Error(`Could not find Next.js config object in ${path.basename(nextConfigPath)}. ` + `Expected either 'export default { ... }' or 'export default wrapper(configVar, ...)'`);
     }
-    const hasOutput = configObject.getProperty('output') !== undefined;
-    if (hasOutput) {
-        return;
+    if (configObject.getProperty('output') === undefined) {
+        configObject.addPropertyAssignment({
+            name: 'output',
+            initializer: "'standalone'"
+        });
+    }
+    addFigmaImageLoaderConfig(configObject);
+    if (!sourceFile.isSaved()) {
+        await sourceFile.save();
     }
-    configObject.addPropertyAssignment({
-        name: 'output',
-        initializer: "'standalone'"
-    });
-    await sourceFile.save();
 }
 /**
  * Find the config object literal from either:

package/dist/utils/lambda-runtime/nextjs-cache.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A process-local, fresh-only Next.js cacheHandler. The CDN owns stale serving.
+ * No filesystem access: Lambda's code directory is read-only. Each cold process
+ * starts empty; Gatekeeper serves the separately uploaded static assets.
+ */
+export default class NextjsCacheHandler {
+    tagVersion: number;
+    get(key: any, context?: {}): Promise<{
+        value: any;
+        lastModified: any;
+    } | null>;
+    set(key: any, value: any, context?: {}): Promise<void>;
+    /**
+     * The revalidateTag function allows invalidating cached data on-demand based
+     * on the specified tags. For our purposes, since we are currently doing a
+     * local in-memory, per-process lambda cache, we can just go ahead and clear
+     * the cache. Eventually we will want to support doing tag invalidation at the
+     * CDN layer.
+     */
+    revalidateTag(tags: any, _durations?: {}): Promise<void>;
+    resetRequestCache(): void;
+}

package/dist/utils/lambda-runtime/nextjs-cache.js

@@ -0,0 +1,162 @@
+import { deserialize, serialize } from 'node:v8';
+const MAX_CACHE_BYTES = 8 * 1024 * 1024;
+// Approximate Map entry and metadata overhead; actual heap use can differ.
+const ESTIMATED_ENTRY_OVERHEAD_BYTES = 64;
+const cache = new Map();
+let cacheBytes = 0;
+// Tag invalidation advances this counter to reject writes from earlier requests.
+let tagVersion = 0;
+/**
+ * A process-local, fresh-only Next.js cacheHandler. The CDN owns stale serving.
+ * No filesystem access: Lambda's code directory is read-only. Each cold process
+ * starts empty; Gatekeeper serves the separately uploaded static assets.
+ */ export default class NextjsCacheHandler {
+    constructor(){
+        this.tagVersion = tagVersion;
+    }
+    async get(key, context = {}) {
+        const cacheKey = getCacheKey(key, context.kind === 'FETCH');
+        const entry = cache.get(cacheKey);
+        if (!entry) {
+            observe('miss', context.kind);
+            return null;
+        }
+        const effectiveTTL = context.kind === 'FETCH' && context.revalidate !== undefined ? Math.min(entry.seconds, lifetime(context.revalidate)) : entry.seconds;
+        const ageMs = Math.max(0, Date.now() - entry.lastModified);
+        if (ageMs >= effectiveTTL * 1000) {
+            if (ageMs >= entry.seconds * 1000) {
+                remove(cacheKey);
+            }
+            observe('expired', context.kind);
+            return null;
+        }
+        // Clone cached buffers/maps so a caller cannot mutate the stored value.
+        // V8 can return Buffer views into its input, so copy the serialized bytes.
+        const value = deserialize(Buffer.from(entry.data));
+        if (value && [
+            'APP_PAGE',
+            'APP_ROUTE',
+            'PAGES'
+        ].includes(value.kind)) {
+            value.headers = withoutAge(value.headers);
+            value.headers.Age = String(Math.floor(ageMs / 1000));
+        }
+        cache.delete(cacheKey);
+        cache.set(cacheKey, entry);
+        observe('hit', context.kind);
+        return {
+            value,
+            lastModified: entry.lastModified
+        };
+    }
+    async set(key, value, context = {}) {
+        // A render that overlaps invalidation must not restore an old value.
+        if (this.tagVersion !== tagVersion) {
+            return;
+        }
+        const cacheKey = getCacheKey(key, context.fetchCache);
+        remove(cacheKey);
+        const seconds = lifetime(context.fetchCache ? value?.revalidate : context.cacheControl?.revalidate);
+        if (seconds === 0) {
+            return;
+        }
+        let data;
+        try {
+            data = serialize(value);
+        } catch  {
+            observe('unsupported', value?.kind);
+            return;
+        }
+        const size = data.byteLength + Buffer.byteLength(cacheKey) + ESTIMATED_ENTRY_OVERHEAD_BYTES;
+        if (size > MAX_CACHE_BYTES) {
+            observe('oversized', value?.kind);
+            return;
+        }
+        // Preserve an upstream Age, including a previous cached response that Next
+        // attempts to write again after an unsuccessful on-demand revalidation.
+        const age = responseAge(value);
+        if (age >= seconds) {
+            return;
+        }
+        while(cacheBytes + size > MAX_CACHE_BYTES){
+            remove(cache.keys().next().value);
+        }
+        cache.set(cacheKey, {
+            data,
+            size,
+            seconds,
+            lastModified: Date.now() - age * 1000
+        });
+        cacheBytes += size;
+    }
+    /**
+   * The revalidateTag function allows invalidating cached data on-demand based
+   * on the specified tags. For our purposes, since we are currently doing a
+   * local in-memory, per-process lambda cache, we can just go ahead and clear
+   * the cache. Eventually we will want to support doing tag invalidation at the
+   * CDN layer.
+   */ async revalidateTag(tags, _durations = {}) {
+        const tagsArr = Array.isArray(tags) ? tags : [
+            tags
+        ];
+        const hasValidTag = tagsArr.some((tag)=>typeof tag === 'string' && tag.length);
+        if (!hasValidTag) {
+            return;
+        }
+        cache.clear();
+        cacheBytes = 0;
+        tagVersion += 1;
+        observe('invalidated', 'local');
+    }
+    // Outstanding writes still belong to the request that started before invalidation.
+    resetRequestCache() {}
+}
+function getCacheKey(key, fetchCache) {
+    return `${fetchCache ? 'fetch' : 'route'}:${key}`;
+}
+function lifetime(revalidate) {
+    if (revalidate === false) {
+        return Infinity;
+    }
+    return Number.isSafeInteger(revalidate) && revalidate > 0 ? revalidate : 0;
+}
+function remove(key) {
+    const entry = cache.get(key);
+    if (entry) {
+        cacheBytes -= entry.size;
+    }
+    cache.delete(key);
+}
+function withoutAge(headers) {
+    return Object.fromEntries(Object.entries(headers ?? {}).filter(([name])=>name.toLowerCase() !== 'age'));
+}
+function responseAge(value) {
+    if (!value || value.kind === 'FETCH') {
+        return 0;
+    }
+    const age = Object.entries(value.headers ?? {}).find(([name])=>name.toLowerCase() === 'age')?.[1];
+    if (age === undefined) {
+        return 0;
+    }
+    if (typeof age !== 'number' && (typeof age !== 'string' || !/^\d+$/.test(age))) {
+        return Infinity;
+    }
+    const seconds = Number(age);
+    return Number.isSafeInteger(seconds) && seconds >= 0 ? seconds : Infinity;
+}
+function observe(result, kind) {
+    if (![
+        'APP_PAGE',
+        'APP_ROUTE',
+        'PAGES',
+        'local'
+    ].includes(kind)) {
+        return;
+    }
+    // Bounded fields only: never log cache keys, URLs, values, or tags.
+    console.info(JSON.stringify({
+        event: 'figma_nextjs_cache',
+        result,
+        kind
+    }));
+}

package/dist/utils/next-image-loader-config.d.ts

@@ -0,0 +1,2 @@
+import type { ObjectLiteralExpression } from 'ts-morph';
+export declare function addFigmaImageLoaderConfig(configObject: ObjectLiteralExpression): void;

package/dist/utils/next-image-loader-config.js

@@ -0,0 +1,63 @@
+import { Node, SyntaxKind } from 'ts-morph';
+import { FIGMA_IMAGE_LOADER_PATH } from './next-image-loader-file.js';
+export function addFigmaImageLoaderConfig(configObject) {
+    const imagesProperty = configObject.getProperty('images');
+    if (!imagesProperty) {
+        configObject.addPropertyAssignment({
+            name: 'images',
+            initializer: `{
+        loader: 'custom',
+        loaderFile: '${FIGMA_IMAGE_LOADER_PATH}',
+      }`
+        });
+        return;
+    }
+    let imagesValue;
+    if (Node.isPropertyAssignment(imagesProperty)) {
+        imagesValue = imagesProperty.getInitializer();
+    } else if (Node.isShorthandPropertyAssignment(imagesProperty)) {
+        imagesValue = imagesProperty.getNameNode();
+    }
+    const imagesObject = resolveLocalObjectLiteral(imagesValue);
+    if (!imagesObject) {
+        throw new Error('Figma could not add the image loader because it could not inspect the `images` configuration. ' + 'Define `images` as an object in this Next.js config file and rerun ' + '`npx @payloadcms/figma init`.');
+    }
+    const loaderProperty = imagesObject.getProperty('loader');
+    const loaderFileProperty = imagesObject.getProperty('loaderFile');
+    if (loaderProperty || loaderFileProperty) {
+        const isFigmaLoader = getStringPropertyValue(loaderProperty) === 'custom' && getStringPropertyValue(loaderFileProperty) === FIGMA_IMAGE_LOADER_PATH;
+        if (!isFigmaLoader) {
+            throw new Error('A custom Next.js image loader is already configured, so Figma left it unchanged. ' + 'Remove the existing images.loader and images.loaderFile settings and rerun ' + '`npx @payloadcms/figma init`.');
+        }
+        return;
+    }
+    imagesObject.addPropertyAssignment({
+        name: 'loader',
+        initializer: "'custom'"
+    });
+    imagesObject.addPropertyAssignment({
+        name: 'loaderFile',
+        initializer: `'${FIGMA_IMAGE_LOADER_PATH}'`
+    });
+}
+function resolveLocalObjectLiteral(node) {
+    if (Node.isObjectLiteralExpression(node)) {
+        return node;
+    }
+    if (!Node.isIdentifier(node)) {
+        return undefined;
+    }
+    const sourceFile = node.getSourceFile();
+    for (const definition of node.getDefinitionNodes()){
+        if (Node.isVariableDeclaration(definition) && definition.getSourceFile() === sourceFile) {
+            return definition.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
+        }
+    }
+    return undefined;
+}
+function getStringPropertyValue(property) {
+    if (!property || !Node.isPropertyAssignment(property)) {
+        return undefined;
+    }
+    return property.getInitializerIfKind(SyntaxKind.StringLiteral)?.getLiteralValue();
+}

package/dist/utils/next-image-loader-file.d.ts

@@ -0,0 +1,2 @@
+export declare const FIGMA_IMAGE_LOADER_PATH = "./figma-image-loader.ts";
+export declare function writeFigmaImageLoaderFile(projectPath: string): Promise<void>;

package/dist/utils/next-image-loader-file.js

@@ -0,0 +1,11 @@
+import fs from 'fs/promises';
+import path from 'path';
+export const FIGMA_IMAGE_LOADER_PATH = './figma-image-loader.ts';
+const FIGMA_IMAGE_LOADER_CONTENT = `'use client'
+
+// Generated by @payloadcms/figma. Do not edit.
+export { figmaNextImageLoader as default } from '@payloadcms/figma/next-image-loader'
+`;
+export async function writeFigmaImageLoaderFile(projectPath) {
+    await fs.writeFile(path.join(projectPath, FIGMA_IMAGE_LOADER_PATH), FIGMA_IMAGE_LOADER_CONTENT);
+}