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

package/dist/utils/payload-generate.js

@@ -0,0 +1,59 @@
+import spawn from 'cross-spawn';
+import path from 'path';
+// buildFigmaConfig throws without a resolvable environmentId/contentSystemId,
+// which an unauthenticated init lacks. It reads these env vars before the
+// bootstrap cache, so injecting them avoids the throw. Always inject the
+// placeholder (not the real env) for deterministic behavior; the generated
+// artifacts are ID-independent, so the value never affects output.
+const GENERATE_PLACEHOLDER = 'figma-generate-placeholder';
+/** Runs `payload <subcommand>` via the project's local binary. Never throws. */ function runPayloadGenerate(projectPath, subcommand) {
+    const bin = path.join(projectPath, 'node_modules', '.bin', 'payload');
+    return new Promise((resolve)=>{
+        const child = spawn(bin, [
+            subcommand
+        ], {
+            cwd: projectPath,
+            env: {
+                ...process.env,
+                FIGMA_CONTENT_API_CONTENT_SYSTEM_ID: GENERATE_PLACEHOLDER,
+                FIGMA_EID: GENERATE_PLACEHOLDER
+            },
+            stdio: 'pipe'
+        });
+        // Drain both pipes. An unread stdout buffer fills and blocks the child,
+        // hanging init; stdout also carries diagnostics on some failures.
+        let stderr = '';
+        let stdout = '';
+        child.stderr?.on('data', (data)=>{
+            stderr += data.toString();
+        });
+        child.stdout?.on('data', (data)=>{
+            stdout += data.toString();
+        });
+        child.on('close', (code)=>{
+            if (code === 0) {
+                resolve({
+                    ok: true
+                });
+            } else {
+                const output = stderr.trim() || stdout.trim();
+                resolve({
+                    error: output || `payload ${subcommand} exited with code ${code}`,
+                    ok: false
+                });
+            }
+        });
+        child.on('error', (error)=>{
+            resolve({
+                error: error.message,
+                ok: false
+            });
+        });
+    });
+}
+/** Never throws. */ export function generateImportMap(projectPath) {
+    return runPayloadGenerate(projectPath, 'generate:importmap');
+}
+/** Never throws. */ export function generateTypes(projectPath) {
+    return runPayloadGenerate(projectPath, 'generate:types');
+}

package/dist/utils/pnpm-builds.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Write init's pnpm-workspace.yaml: hoisted node linker (the Lambda runtime needs a
+ * flat node_modules) plus build approvals, migrating off the now-ignored package.json
+ * `pnpm.onlyBuiltDependencies`. Written for every project so an npx/npm scaffold still
+ * installs cleanly when the user later switches to pnpm.
+ */
+export declare function ensurePnpmWorkspace(projectPath: string): Promise<void>;
+/**
+ * Set each build `true` under `allowBuilds` and drop it from any `ignoredBuiltDependencies`
+ * denylist. Pure and idempotent. pnpm v11 reads approvals only from pnpm-workspace.yaml.
+ */
+export declare function upsertBuildApprovals(content: string, builds: string[]): string;
+/** Set a top-level `key: value` scalar, replacing any existing one. Pure and idempotent. */
+export declare function upsertTopLevelScalar(content: string, key: string, value: string): string;

package/dist/utils/pnpm-builds.js

@@ -0,0 +1,125 @@
+import fs from 'fs/promises';
+import path from 'path';
+/** Fallback builds when package.json declares none. */ const DEFAULT_BUILDS = [
+    'sharp',
+    'esbuild',
+    'unrs-resolver'
+];
+/**
+ * Write init's pnpm-workspace.yaml: hoisted node linker (the Lambda runtime needs a
+ * flat node_modules) plus build approvals, migrating off the now-ignored package.json
+ * `pnpm.onlyBuiltDependencies`. Written for every project so an npx/npm scaffold still
+ * installs cleanly when the user later switches to pnpm.
+ */ export async function ensurePnpmWorkspace(projectPath) {
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+    const pnpmField = packageJson.pnpm;
+    const configured = pnpmField?.onlyBuiltDependencies;
+    const builds = configured && configured.length > 0 ? configured : DEFAULT_BUILDS;
+    const workspacePath = path.join(projectPath, 'pnpm-workspace.yaml');
+    let yaml = '';
+    try {
+        yaml = await fs.readFile(workspacePath, 'utf-8');
+    } catch (error) {
+        // Rethrow on a present-but-unreadable file; the write below would clobber it.
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    yaml = upsertTopLevelScalar(yaml, 'nodeLinker', 'hoisted');
+    yaml = upsertBuildApprovals(yaml, builds);
+    await fs.writeFile(workspacePath, yaml, 'utf-8');
+    if (pnpmField) {
+        delete pnpmField.onlyBuiltDependencies;
+        if (Object.keys(pnpmField).length === 0) {
+            delete packageJson.pnpm;
+        }
+        await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf-8');
+    }
+}
+/**
+ * Set each build `true` under `allowBuilds` and drop it from any `ignoredBuiltDependencies`
+ * denylist. Pure and idempotent. pnpm v11 reads approvals only from pnpm-workspace.yaml.
+ */ export function upsertBuildApprovals(content, builds) {
+    const blocks = toTopLevelBlocks(content);
+    const ignored = blocks.find((block)=>block.key === 'ignoredBuiltDependencies');
+    if (ignored) {
+        ignored.lines = ignored.lines.filter((line, index)=>{
+            if (index === 0) {
+                return true;
+            }
+            const name = /^\s*-\s*'?([^'\s]+)'?\s*$/.exec(line)?.[1];
+            return !(name && builds.includes(name));
+        });
+    }
+    const allow = blocks.find((block)=>block.key === 'allowBuilds');
+    if (allow) {
+        for (const name of builds){
+            const pattern = new RegExp(`^\\s+'?${escapeRegExp(name)}'?:`);
+            const index = allow.lines.findIndex((line)=>pattern.test(line));
+            if (index >= 0) {
+                allow.lines[index] = `  ${name}: true`;
+            } else {
+                allow.lines.push(`  ${name}: true`);
+            }
+        }
+    } else {
+        blocks.push({
+            key: 'allowBuilds',
+            lines: [
+                'allowBuilds:',
+                ...builds.map((name)=>`  ${name}: true`)
+            ]
+        });
+    }
+    const output = blocks.flatMap((block)=>block.lines).join('\n');
+    return output.endsWith('\n') ? output : `${output}\n`;
+}
+/** Set a top-level `key: value` scalar, replacing any existing one. Pure and idempotent. */ export function upsertTopLevelScalar(content, key, value) {
+    const blocks = toTopLevelBlocks(content);
+    const line = `${key}: ${value}`;
+    const existing = blocks.find((block)=>block.key === key);
+    if (existing) {
+        existing.lines = [
+            line
+        ];
+    } else {
+        blocks.push({
+            key,
+            lines: [
+                line
+            ]
+        });
+    }
+    const output = blocks.flatMap((block)=>block.lines).join('\n');
+    return output.endsWith('\n') ? output : `${output}\n`;
+}
+function toTopLevelBlocks(content) {
+    const lines = content.length ? content.replace(/\n$/, '').split('\n') : [];
+    const blocks = [];
+    for (const line of lines){
+        const key = /^[^\s#]/.test(line) ? /^([^:]+):/.exec(line)?.[1] : undefined;
+        const current = blocks[blocks.length - 1];
+        if (key !== undefined) {
+            blocks.push({
+                key,
+                lines: [
+                    line
+                ]
+            });
+        } else if (current) {
+            current.lines.push(line);
+        } else {
+            blocks.push({
+                key: null,
+                lines: [
+                    line
+                ]
+            });
+        }
+    }
+    return blocks;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/figma",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.0-alpha.4",
   "license": "SEE LICENSE IN LICENSE.md",
   "type": "module",
   "exports": {
@@ -41,6 +41,7 @@
     "open": "^10.2.0",
     "openapi-fetch": "0.15.0",
     "picocolors": "1.1.1",
+    "skills": "1.4.4",
     "tar": "^7.5.13",
     "terminal-link": "^5.0.0",
     "ts-morph": "^21.0.1",

package/dist/lib/download-skill.d.ts

@@ -1,12 +0,0 @@
-export type DownloadSkillResult = {
-    detail?: string;
-    ok: false;
-    reason: 'already-installed' | 'empty-extract' | 'error' | 'fetch-failed';
-} | {
-    ok: true;
-};
-export declare function downloadSkill(args: {
-    branch?: string;
-    debug?: boolean;
-    projectDir: string;
-}): Promise<DownloadSkillResult>;

package/dist/lib/download-skill.js

@@ -1,77 +0,0 @@
-import fs from 'fs/promises';
-import { Readable } from 'node:stream';
-import { pipeline } from 'node:stream/promises';
-import path from 'path';
-import { x } from 'tar';
-export async function downloadSkill(args) {
-    const { branch = 'main', debug, projectDir } = args;
-    const destDir = path.join(projectDir, '.claude', 'skills', 'payload');
-    if (await pathExists(path.join(destDir, 'SKILL.md'))) {
-        return {
-            ok: false,
-            reason: 'already-installed'
-        };
-    }
-    const url = `https://codeload.github.com/payloadcms/payload/tar.gz/${branch}`;
-    const filter = `payload-${branch.replace(/^v/, '').replaceAll('/', '-')}/tools/claude-plugin/skills/payload/`;
-    if (debug) {
-        // eslint-disable-next-line no-console
-        console.log(`[download-skill] url=${url} dest=${destDir}`);
-    }
-    try {
-        const res = await fetch(url);
-        if (!res.ok) {
-            return {
-                detail: `${res.status} ${res.statusText}`,
-                ok: false,
-                reason: 'fetch-failed'
-            };
-        }
-        if (!res.body) {
-            return {
-                detail: 'empty response body',
-                ok: false,
-                reason: 'fetch-failed'
-            };
-        }
-        await fs.mkdir(destDir, {
-            recursive: true
-        });
-        await pipeline(Readable.from(res.body), x({
-            cwd: destDir,
-            filter: (p)=>p.includes(filter),
-            strip: filter.split('/').length - 1
-        }));
-        if (!await pathExists(path.join(destDir, 'SKILL.md'))) {
-            await fs.rm(destDir, {
-                force: true,
-                recursive: true
-            });
-            return {
-                ok: false,
-                reason: 'empty-extract'
-            };
-        }
-        return {
-            ok: true
-        };
-    } catch (err) {
-        await fs.rm(destDir, {
-            force: true,
-            recursive: true
-        }).catch(()=>{});
-        return {
-            detail: err instanceof Error ? err.message : String(err),
-            ok: false,
-            reason: 'error'
-        };
-    }
-}
-async function pathExists(p) {
-    try {
-        await fs.access(p);
-        return true;
-    } catch  {
-        return false;
-    }
-}