@delmaredigital/payload-puck 0.6.12 → 0.6.14

package/dist/plugin/index.js

@@ -1,21 +1,20 @@
-import { generatePagesCollection } from './collections/Pages';
-import { TemplatesCollection } from '../collections/Templates';
+import { generatePagesCollection } from './collections/Pages.js';
+import { TemplatesCollection } from '../collections/Templates.js';
 import { AiPromptsCollection } from '../ai/collections/AiPrompts.js';
 import { AiContextCollection } from '../ai/collections/AiContext.js';
-import { getPuckFields } from './fields';
-import { createIsHomepageUniqueHook } from './hooks/isHomepageUnique';
-import { createListHandler, createCreateHandler, createGetHandler, createUpdateHandler, createDeleteHandler, createVersionsHandler, createRestoreHandler, } from '../endpoints/index.js';
+import { getPuckFields } from './fields/index.js';
+import { createIsHomepageUniqueHook } from './hooks/isHomepageUnique.js';
+import { createListHandler, createCreateHandler, createGetHandler, createUpdateHandler, createDeleteHandler, createVersionsHandler, createRestoreHandler } from '../endpoints/index.js';
 import { createStylesHandler, PUCK_STYLES_ENDPOINT } from '../endpoints/styles.js';
 import { createAiEndpointHandler } from '../endpoints/ai.js';
-import { createPromptsListHandler, createPromptsCreateHandler, createPromptsUpdateHandler, createPromptsDeleteHandler, } from '../endpoints/prompts.js';
-import { createContextListHandler, createContextCreateHandler, createContextUpdateHandler, createContextDeleteHandler, } from '../endpoints/context.js';
+import { createPromptsListHandler, createPromptsCreateHandler, createPromptsUpdateHandler, createPromptsDeleteHandler } from '../endpoints/prompts.js';
+import { createContextListHandler, createContextCreateHandler, createContextUpdateHandler, createContextDeleteHandler } from '../endpoints/context.js';
 /**
  * Get all field names from a collection's fields array (including nested group fields and tabs)
- */
-function getExistingFieldNames(fields) {
+ */ function getExistingFieldNames(fields) {
     const names = new Set();
     function addFieldNames(fieldsToCheck) {
-        for (const field of fieldsToCheck) {
+        for (const field of fieldsToCheck){
             // Add the field name if it has one
             if ('name' in field && field.name) {
                 names.add(field.name);
@@ -26,7 +25,7 @@ function getExistingFieldNames(fields) {
             }
             // Check fields inside tabs
             if (field.type === 'tabs' && 'tabs' in field && Array.isArray(field.tabs)) {
-                for (const tab of field.tabs) {
+                for (const tab of field.tabs){
                     if ('fields' in tab && Array.isArray(tab.fields)) {
                         addFieldNames(tab.fields);
                     }
@@ -39,38 +38,38 @@ function getExistingFieldNames(fields) {
 }
 /**
  * Filter out fields that already exist in the target collection
- */
-function filterExistingFields(fieldsToAdd, existingNames) {
-    return fieldsToAdd.filter((field) => {
+ */ function filterExistingFields(fieldsToAdd, existingNames) {
+    return fieldsToAdd.filter((field)=>{
         if ('name' in field && field.name) {
             return !existingNames.has(field.name);
         }
-        return true; // Keep fields without names (like UI fields)
+        return true // Keep fields without names (like UI fields)
+        ;
     });
 }
 /**
  * Generates the UI field configuration for the Edit with Puck button
- */
-function generatePuckEditField(collectionSlug, adminConfig = {}) {
-    const { editorPathPattern = '/pages/{id}/edit', buttonLabel = 'Visual Editor', buttonPosition, // undefined = main area (default), 'sidebar' = sidebar
-     } = adminConfig;
+ */ function generatePuckEditField(collectionSlug, adminConfig = {}) {
+    const { editorPathPattern = '/pages/{id}/edit', buttonLabel = 'Visual Editor', buttonPosition } = adminConfig;
     return {
         name: 'puckEdit',
         type: 'ui',
         admin: {
             // Only set position if explicitly specified (sidebar)
             // undefined means main form area in Payload
-            ...(buttonPosition && { position: buttonPosition }),
+            ...buttonPosition && {
+                position: buttonPosition
+            },
             components: {
                 Field: '@delmaredigital/payload-puck/admin/client#EditWithPuckButton',
-                Cell: '@delmaredigital/payload-puck/admin/client#EditWithPuckCell',
+                Cell: '@delmaredigital/payload-puck/admin/client#EditWithPuckCell'
             },
             custom: {
                 collectionSlug,
                 editorPathPattern,
-                label: buttonLabel,
-            },
-        },
+                label: buttonLabel
+            }
+        }
     };
 }
 /**
@@ -105,10 +104,8 @@ function generatePuckEditField(collectionSlug, adminConfig = {}) {
  *   ],
  * })
  * ```
- */
-export function createPuckPlugin(options = {}) {
-    const { pagesCollection = 'pages', autoGenerateCollection = true, admin: pluginAdminConfig = {}, enableAdminView = true, adminViewPath = '/puck-editor', enableEndpoints = true, pageTreeIntegration, // No default - undefined means auto-detect
-    editorStylesheet, editorStylesheetUrls = [], editorStylesheetCompiled, ai: aiConfig, previewUrl, } = options;
+ */ export function createPuckPlugin(options = {}) {
+    const { pagesCollection = 'pages', autoGenerateCollection = true, admin: pluginAdminConfig = {}, enableAdminView = true, adminViewPath = '/puck-editor', enableEndpoints = true, pageTreeIntegration, editorStylesheet, editorStylesheetUrls = [], editorStylesheetCompiled, ai: aiConfig, previewUrl } = options;
     const { addEditButton = true } = pluginAdminConfig;
     // Parse page-tree integration config
     // - undefined: auto-detect at runtime (null stored, view will check for pageSegment field)
@@ -119,58 +116,64 @@ export function createPuckPlugin(options = {}) {
     if (pageTreeIntegration === undefined) {
         // Not specified - store null to trigger auto-detection in the view
         pageTreeConfig = null;
-    }
-    else if (pageTreeIntegration === false) {
+    } else if (pageTreeIntegration === false) {
         // Explicitly disabled - store false to prevent auto-detection
         pageTreeConfig = false;
-    }
-    else if (pageTreeIntegration === true) {
+    } else if (pageTreeIntegration === true) {
         // Explicitly enabled with defaults
         pageTreeConfig = {
             folderSlug: 'payload-folders',
             segmentFieldName: 'pathSegment',
             pageSegmentFieldName: 'pageSegment',
-            folderFieldName: 'folder',
+            folderFieldName: 'folder'
         };
-    }
-    else {
+    } else {
         // Custom config object
         pageTreeConfig = {
             folderSlug: pageTreeIntegration.folderSlug ?? 'payload-folders',
             segmentFieldName: pageTreeIntegration.segmentFieldName ?? 'pathSegment',
             pageSegmentFieldName: pageTreeIntegration.pageSegmentFieldName ?? 'pageSegment',
-            folderFieldName: pageTreeIntegration.folderFieldName ?? 'folder',
+            folderFieldName: pageTreeIntegration.folderFieldName ?? 'folder'
         };
     }
-    return (incomingConfig) => {
+    return (incomingConfig)=>{
         // Generate Pages collection if auto-generate is enabled
         let collections = incomingConfig.collections || [];
         // Always add the Templates collection if it doesn't exist
-        const templatesCollectionExists = collections.some((c) => c.slug === 'puck-templates');
+        const templatesCollectionExists = collections.some((c)=>c.slug === 'puck-templates');
         if (!templatesCollectionExists) {
-            collections = [...collections, TemplatesCollection];
+            collections = [
+                ...collections,
+                TemplatesCollection
+            ];
         }
         // Add AI Prompts collection if AI is enabled with promptsCollection
         if (aiConfig?.enabled && aiConfig?.promptsCollection) {
-            const aiPromptsExists = collections.some((c) => c.slug === 'puck-ai-prompts');
+            const aiPromptsExists = collections.some((c)=>c.slug === 'puck-ai-prompts');
             if (!aiPromptsExists) {
-                collections = [...collections, AiPromptsCollection];
+                collections = [
+                    ...collections,
+                    AiPromptsCollection
+                ];
             }
         }
         // Add AI Context collection if AI is enabled with contextCollection
         if (aiConfig?.enabled && aiConfig?.contextCollection) {
-            const aiContextExists = collections.some((c) => c.slug === 'puck-ai-context');
+            const aiContextExists = collections.some((c)=>c.slug === 'puck-ai-context');
             if (!aiContextExists) {
-                collections = [...collections, AiContextCollection];
+                collections = [
+                    ...collections,
+                    AiContextCollection
+                ];
             }
         }
         if (autoGenerateCollection) {
             // Check if collection already exists
-            const existingCollectionIndex = collections.findIndex((c) => c.slug === pagesCollection);
+            const existingCollectionIndex = collections.findIndex((c)=>c.slug === pagesCollection);
             // Generate the edit button field if enabled
-            const editButtonField = addEditButton
-                ? [generatePuckEditField(pagesCollection, pluginAdminConfig)]
-                : [];
+            const editButtonField = addEditButton ? [
+                generatePuckEditField(pagesCollection, pluginAdminConfig)
+            ] : [];
             if (existingCollectionIndex >= 0) {
                 // Collection exists - only add Puck fields that don't already exist
                 const existingCollection = collections[existingCollectionIndex];
@@ -186,7 +189,7 @@ export function createPuckPlugin(options = {}) {
                     includeEditorVersion: !existingFieldNames.has('editorVersion'),
                     includePageLayout: !existingFieldNames.has('pageLayout'),
                     includeIsHomepage: shouldAddIsHomepage,
-                    layouts: options.layouts,
+                    layouts: options.layouts
                 });
                 // Filter out any remaining duplicates (e.g., puckData if user already has it)
                 const fieldsToAdd = filterExistingFields(puckFields, existingFieldNames);
@@ -194,48 +197,51 @@ export function createPuckPlugin(options = {}) {
                 const editFieldsToAdd = existingFieldNames.has('puckEdit') ? [] : editButtonField;
                 // Merge hooks - add isHomepage uniqueness hook if we're adding the field
                 const existingHooks = existingCollection.hooks || {};
-                const mergedHooks = shouldAddIsHomepage
-                    ? {
-                        ...existingHooks,
-                        beforeChange: [
-                            createIsHomepageUniqueHook(),
-                            ...(existingHooks.beforeChange ?? []),
-                        ],
-                    }
-                    : existingHooks;
+                const mergedHooks = shouldAddIsHomepage ? {
+                    ...existingHooks,
+                    beforeChange: [
+                        createIsHomepageUniqueHook(),
+                        ...existingHooks.beforeChange ?? []
+                    ]
+                } : existingHooks;
                 collections = [
                     ...collections.slice(0, existingCollectionIndex),
                     {
                         ...existingCollection,
                         // Ensure drafts are enabled for Puck
-                        versions: typeof existingCollection.versions === 'object'
-                            ? { drafts: true, ...existingCollection.versions }
-                            : existingCollection.versions ?? { drafts: true },
+                        versions: typeof existingCollection.versions === 'object' ? {
+                            drafts: true,
+                            ...existingCollection.versions
+                        } : existingCollection.versions ?? {
+                            drafts: true
+                        },
                         hooks: mergedHooks,
                         fields: [
                             ...existingFields,
                             ...fieldsToAdd,
-                            ...editFieldsToAdd,
-                        ],
+                            ...editFieldsToAdd
+                        ]
                     },
-                    ...collections.slice(existingCollectionIndex + 1),
+                    ...collections.slice(existingCollectionIndex + 1)
                 ];
-            }
-            else {
+            } else {
                 // Add new collection with edit button field
                 const generatedCollection = generatePagesCollection(pagesCollection, options);
                 collections = [
                     ...collections,
                     {
                         ...generatedCollection,
-                        fields: [...generatedCollection.fields, ...editButtonField],
-                    },
+                        fields: [
+                            ...generatedCollection.fields,
+                            ...editButtonField
+                        ]
+                    }
                 ];
             }
         }
         // Build the admin config with view registration
         const payloadAdminConfig = {
-            ...incomingConfig.admin,
+            ...incomingConfig.admin
         };
         // Register the Puck editor admin view if enabled
         if (enableAdminView) {
@@ -245,138 +251,135 @@ export function createPuckPlugin(options = {}) {
                     ...payloadAdminConfig.components?.views,
                     puckEditor: {
                         Component: '@delmaredigital/payload-puck/rsc#PuckEditorView',
-                        path: `${adminViewPath}/:segments*`,
-                    },
-                },
+                        path: `${adminViewPath}/:segments*`
+                    }
+                }
             };
         }
         // Register API endpoints if enabled
-        const puckCollections = [pagesCollection];
-        const endpointOptions = { collections: puckCollections };
+        const puckCollections = [
+            pagesCollection
+        ];
+        const endpointOptions = {
+            collections: puckCollections
+        };
         // Build styles endpoint URL list for PuckConfigProvider
         // In production, prefer the pre-compiled static CSS file if provided
         // In development, use runtime compilation endpoint for hot reload
         const isProduction = process.env.NODE_ENV === 'production';
         const useCompiledCss = isProduction && editorStylesheetCompiled;
         const editorStylesheets = [
-            ...(useCompiledCss
-                ? [editorStylesheetCompiled]
-                : editorStylesheet
-                    ? [PUCK_STYLES_ENDPOINT]
-                    : []),
-            ...editorStylesheetUrls,
+            ...useCompiledCss ? [
+                editorStylesheetCompiled
+            ] : editorStylesheet ? [
+                PUCK_STYLES_ENDPOINT
+            ] : [],
+            ...editorStylesheetUrls
         ];
-        const endpoints = enableEndpoints
-            ? [
-                ...(incomingConfig.endpoints || []),
-                // Styles endpoint MUST be first - exact match before parameterized routes
-                ...(editorStylesheet
-                    ? [
-                        {
-                            path: '/puck/styles',
-                            method: 'get',
-                            handler: createStylesHandler(editorStylesheet),
-                        },
-                    ]
-                    : []),
-                // AI endpoint (exact match, before parameterized routes)
-                ...(aiConfig?.enabled
-                    ? [
-                        {
-                            path: '/puck/ai',
-                            method: 'post',
-                            handler: createAiEndpointHandler({ context: aiConfig.context, tools: aiConfig.tools }),
-                        },
-                    ]
-                    : []),
-                // AI Prompts CRUD endpoints (exact match, before parameterized routes)
-                ...(aiConfig?.enabled && aiConfig?.promptsCollection
-                    ? [
-                        {
-                            path: '/puck/ai-prompts',
-                            method: 'get',
-                            handler: createPromptsListHandler(),
-                        },
-                        {
-                            path: '/puck/ai-prompts',
-                            method: 'post',
-                            handler: createPromptsCreateHandler(),
-                        },
-                        {
-                            path: '/puck/ai-prompts/:id',
-                            method: 'patch',
-                            handler: createPromptsUpdateHandler(),
-                        },
-                        {
-                            path: '/puck/ai-prompts/:id',
-                            method: 'delete',
-                            handler: createPromptsDeleteHandler(),
-                        },
-                    ]
-                    : []),
-                // AI Context CRUD endpoints (exact match, before parameterized routes)
-                ...(aiConfig?.enabled && aiConfig?.contextCollection
-                    ? [
-                        {
-                            path: '/puck/ai-context',
-                            method: 'get',
-                            handler: createContextListHandler(),
-                        },
-                        {
-                            path: '/puck/ai-context',
-                            method: 'post',
-                            handler: createContextCreateHandler(),
-                        },
-                        {
-                            path: '/puck/ai-context/:id',
-                            method: 'patch',
-                            handler: createContextUpdateHandler(),
-                        },
-                        {
-                            path: '/puck/ai-context/:id',
-                            method: 'delete',
-                            handler: createContextDeleteHandler(),
-                        },
-                    ]
-                    : []),
-                // Collection endpoints (parameterized routes)
+        const endpoints = enableEndpoints ? [
+            ...incomingConfig.endpoints || [],
+            // Styles endpoint MUST be first - exact match before parameterized routes
+            ...editorStylesheet ? [
                 {
-                    path: '/puck/:collection',
+                    path: '/puck/styles',
                     method: 'get',
-                    handler: createListHandler(endpointOptions),
-                },
+                    handler: createStylesHandler(editorStylesheet)
+                }
+            ] : [],
+            // AI endpoint (exact match, before parameterized routes)
+            ...aiConfig?.enabled ? [
                 {
-                    path: '/puck/:collection',
+                    path: '/puck/ai',
                     method: 'post',
-                    handler: createCreateHandler(endpointOptions),
-                },
+                    handler: createAiEndpointHandler({
+                        context: aiConfig.context,
+                        tools: aiConfig.tools
+                    })
+                }
+            ] : [],
+            // AI Prompts CRUD endpoints (exact match, before parameterized routes)
+            ...aiConfig?.enabled && aiConfig?.promptsCollection ? [
                 {
-                    path: '/puck/:collection/:id',
+                    path: '/puck/ai-prompts',
                     method: 'get',
-                    handler: createGetHandler(endpointOptions),
+                    handler: createPromptsListHandler()
+                },
+                {
+                    path: '/puck/ai-prompts',
+                    method: 'post',
+                    handler: createPromptsCreateHandler()
                 },
                 {
-                    path: '/puck/:collection/:id',
+                    path: '/puck/ai-prompts/:id',
                     method: 'patch',
-                    handler: createUpdateHandler(endpointOptions),
+                    handler: createPromptsUpdateHandler()
                 },
                 {
-                    path: '/puck/:collection/:id',
+                    path: '/puck/ai-prompts/:id',
                     method: 'delete',
-                    handler: createDeleteHandler(endpointOptions),
-                },
+                    handler: createPromptsDeleteHandler()
+                }
+            ] : [],
+            // AI Context CRUD endpoints (exact match, before parameterized routes)
+            ...aiConfig?.enabled && aiConfig?.contextCollection ? [
                 {
-                    path: '/puck/:collection/:id/versions',
+                    path: '/puck/ai-context',
                     method: 'get',
-                    handler: createVersionsHandler(endpointOptions),
+                    handler: createContextListHandler()
                 },
                 {
-                    path: '/puck/:collection/:id/restore',
+                    path: '/puck/ai-context',
                     method: 'post',
-                    handler: createRestoreHandler(endpointOptions),
+                    handler: createContextCreateHandler()
                 },
-            ]
-            : incomingConfig.endpoints || [];
+                {
+                    path: '/puck/ai-context/:id',
+                    method: 'patch',
+                    handler: createContextUpdateHandler()
+                },
+                {
+                    path: '/puck/ai-context/:id',
+                    method: 'delete',
+                    handler: createContextDeleteHandler()
+                }
+            ] : [],
+            // Collection endpoints (parameterized routes)
+            {
+                path: '/puck/:collection',
+                method: 'get',
+                handler: createListHandler(endpointOptions)
+            },
+            {
+                path: '/puck/:collection',
+                method: 'post',
+                handler: createCreateHandler(endpointOptions)
+            },
+            {
+                path: '/puck/:collection/:id',
+                method: 'get',
+                handler: createGetHandler(endpointOptions)
+            },
+            {
+                path: '/puck/:collection/:id',
+                method: 'patch',
+                handler: createUpdateHandler(endpointOptions)
+            },
+            {
+                path: '/puck/:collection/:id',
+                method: 'delete',
+                handler: createDeleteHandler(endpointOptions)
+            },
+            {
+                path: '/puck/:collection/:id/versions',
+                method: 'get',
+                handler: createVersionsHandler(endpointOptions)
+            },
+            {
+                path: '/puck/:collection/:id/restore',
+                method: 'post',
+                handler: createRestoreHandler(endpointOptions)
+            }
+        ] : incomingConfig.endpoints || [];
         return {
             ...incomingConfig,
             admin: payloadAdminConfig,
@@ -395,35 +398,32 @@ export function createPuckPlugin(options = {}) {
                     // Preview URL configuration
                     previewUrl,
                     // AI configuration
-                    ai: aiConfig?.enabled
-                        ? {
-                            enabled: true,
-                            context: aiConfig.context,
-                            examplePrompts: aiConfig.examplePrompts,
-                            promptsCollection: aiConfig.promptsCollection,
-                            contextCollection: aiConfig.contextCollection,
-                        }
-                        : undefined,
-                },
+                    ai: aiConfig?.enabled ? {
+                        enabled: true,
+                        context: aiConfig.context,
+                        examplePrompts: aiConfig.examplePrompts,
+                        promptsCollection: aiConfig.promptsCollection,
+                        contextCollection: aiConfig.contextCollection
+                    } : undefined
+                }
             },
-            onInit: async (payload) => {
+            onInit: async (payload)=>{
                 // Call existing onInit if present
                 if (incomingConfig.onInit) {
                     await incomingConfig.onInit(payload);
                 }
-            },
+            }
         };
     };
 }
 // Re-export collection utilities
-export { generatePagesCollection } from './collections/Pages';
-export { TemplatesCollection } from '../collections/Templates';
+export { generatePagesCollection } from './collections/Pages.js';
+export { TemplatesCollection } from '../collections/Templates.js';
 // Re-export field utilities for hybrid collection integration
-export { getPuckFields, getPuckCollectionConfig, puckDataField, editorVersionField, createEditorVersionField, pageLayoutField, createPageLayoutField, isHomepageField, seoFieldGroup, conversionFieldGroup, } from './fields';
+export { getPuckFields, getPuckCollectionConfig, puckDataField, editorVersionField, createEditorVersionField, pageLayoutField, createPageLayoutField, isHomepageField, seoFieldGroup, conversionFieldGroup } from './fields/index.js';
 // Export the edit button generator for hybrid collections
 export { generatePuckEditField };
 // Export styles endpoint constant
 export { PUCK_STYLES_ENDPOINT } from '../endpoints/styles.js';
 // Re-export hooks for hybrid collection integration
-export { createIsHomepageUniqueHook, unsetHomepage, HomepageConflictError, } from './hooks';
-//# sourceMappingURL=index.js.map
+export { createIsHomepageUniqueHook, unsetHomepage, HomepageConflictError } from './hooks/index.js';

package/dist/render/HybridPageRenderer.d.ts

@@ -37,7 +37,7 @@
  * ```
  */
 import type { Data as PuckData } from '@puckeditor/core';
-import { type PageRendererProps } from './PageRenderer';
+import { type PageRendererProps } from './PageRenderer.js';
 import type { ReactNode } from 'react';
 /**
  * Loose input type that accepts Payload's generic JSON field types.
@@ -111,7 +111,7 @@ export interface HybridPageRendererProps<TBlocks = unknown[]> extends Omit<PageR
  * 2. If legacy blocks exist AND legacyRenderer is provided → render with legacyRenderer
  * 3. Otherwise → render fallback
  */
-export declare function HybridPageRenderer<TBlocks = unknown[]>({ page, legacyRenderer, legacyBlocksField, fallback, config, layouts, wrapper, className, }: HybridPageRendererProps<TBlocks>): import("react/jsx-runtime").JSX.Element;
+export declare function HybridPageRenderer<TBlocks = unknown[]>({ page, legacyRenderer, legacyBlocksField, fallback, config, layouts, wrapper, className, }: HybridPageRendererProps<TBlocks>): import("react").JSX.Element;
 /**
  * Converts a loosely-typed page object (e.g., from Payload's generated types)
  * to a properly typed `HybridPageData`.
@@ -138,4 +138,3 @@ export declare function HybridPageRenderer<TBlocks = unknown[]>({ page, legacyRe
  * @throws Error if editorVersion is present but invalid
  */
 export declare function toHybridPageData(page: HybridPageDataInput): HybridPageData;
-//# sourceMappingURL=HybridPageRenderer.d.ts.map