@delmaredigital/payload-puck 0.2.0 → 0.3.1

package/dist/plugin/index.js

@@ -1,569 +1,292 @@
-'use strict';
-
-// src/layouts/defaults.ts
-var defaultLayout = {
-  value: "default",
-  label: "Default",
-  description: "Standard page layout with contained content width",
-  classes: {
-    wrapper: "",
-    container: "mx-auto px-4 sm:px-6 lg:px-8",
-    content: ""
-  },
-  maxWidth: "1200px",
-  fullWidth: false
-};
-var landingLayout = {
-  value: "landing",
-  label: "Landing",
-  description: "Full-width sections with no global container constraints",
-  classes: {
-    wrapper: "",
-    container: "",
-    content: ""
-  },
-  fullWidth: true
-};
-var fullWidthLayout = {
-  value: "full-width",
-  label: "Full Width",
-  description: "Content spans the full viewport width",
-  classes: {
-    wrapper: "w-full",
-    container: "w-full",
-    content: ""
-  },
-  maxWidth: "100%",
-  fullWidth: true
-};
-var DEFAULT_LAYOUTS = [
-  defaultLayout,
-  landingLayout,
-  fullWidthLayout
-];
-
-// src/layouts/utils.ts
-function layoutsToPayloadOptions(layouts) {
-  return layouts.map(({ value, label }) => ({
-    label,
-    value
-  }));
-}
-
-// src/plugin/fields/index.ts
-var puckDataField = {
-  name: "puckData",
-  type: "json",
-  admin: {
-    hidden: true,
-    description: "Puck editor data - managed via visual editor"
-  }
-};
-function createEditorVersionField(defaultValue = "puck", sidebar = true, legacyBlocksFieldName = "layout") {
-  return {
-    name: "editorVersion",
-    type: "select",
-    // NO defaultValue here - we use the hook to intelligently detect the value
-    // This prevents migrations from blindly setting 'puck' on legacy pages
-    options: [
-      { label: "Legacy (Payload Blocks)", value: "legacy" },
-      { label: "Puck Visual Editor", value: "puck" }
-    ],
-    admin: {
-      position: sidebar ? "sidebar" : void 0,
-      description: "Which editor was used to create this page"
-    },
-    hooks: {
-      beforeValidate: [
-        ({ value, data, operation }) => {
-          if (value) return value;
-          const legacyBlocks = data?.[legacyBlocksFieldName];
-          const hasLegacyBlocks = Array.isArray(legacyBlocks) && legacyBlocks.length > 0;
-          const puckData = data?.puckData;
-          const hasPuckData = puckData?.content && Array.isArray(puckData.content) && puckData.content.length > 0;
-          if (hasLegacyBlocks && !hasPuckData) {
-            return "legacy";
-          }
-          if (hasPuckData) {
-            return "puck";
-          }
-          return defaultValue;
-        }
-      ]
-    }
-  };
-}
-var editorVersionField = createEditorVersionField("puck", true);
-function createPageLayoutField(layouts = DEFAULT_LAYOUTS, sidebar = true) {
-  return {
-    name: "pageLayout",
-    type: "select",
-    required: true,
-    defaultValue: "default",
-    options: layoutsToPayloadOptions(layouts),
-    admin: {
-      position: sidebar ? "sidebar" : void 0,
-      description: "Overall page structure and layout style"
-    }
-  };
-}
-var pageLayoutField = createPageLayoutField();
-var isHomepageField = {
-  name: "isHomepage",
-  type: "checkbox",
-  defaultValue: false,
-  admin: {
-    position: "sidebar",
-    description: "Mark this page as the homepage"
-  }
-};
-var seoFieldGroup = {
-  name: "meta",
-  type: "group",
-  label: "SEO",
-  admin: {
-    position: "sidebar"
-  },
-  fields: [
-    {
-      name: "title",
-      type: "text",
-      label: "Meta Title",
-      admin: {
-        description: "Override the page title for search engines"
-      }
-    },
-    {
-      name: "description",
-      type: "textarea",
-      label: "Meta Description",
-      admin: {
-        description: "Description shown in search engine results"
-      }
-    },
-    {
-      name: "image",
-      type: "upload",
-      relationTo: "media",
-      label: "Open Graph Image",
-      admin: {
-        description: "Image shown when sharing on social media"
-      }
-    },
-    {
-      name: "noindex",
-      type: "checkbox",
-      label: "No Index",
-      defaultValue: false,
-      admin: {
-        description: "Prevent search engines from indexing this page"
-      }
-    },
-    {
-      name: "nofollow",
-      type: "checkbox",
-      label: "No Follow",
-      defaultValue: false,
-      admin: {
-        description: "Prevent search engines from following links on this page"
-      }
-    },
-    {
-      name: "excludeFromSitemap",
-      type: "checkbox",
-      label: "Exclude from Sitemap",
-      defaultValue: false,
-      admin: {
-        description: "Exclude this page from the XML sitemap"
-      }
-    }
-  ]
-};
-var DEFAULT_CONVERSION_TYPES = [
-  { label: "Lead", value: "lead" },
-  { label: "Registration", value: "registration" },
-  { label: "Purchase", value: "purchase" },
-  { label: "Donation", value: "donation" },
-  { label: "Newsletter Signup", value: "newsletter" },
-  { label: "Contact Form", value: "contact" },
-  { label: "Custom", value: "custom" }
-];
-function createConversionFieldGroup(conversionTypes = DEFAULT_CONVERSION_TYPES, sidebar = true) {
-  return {
-    name: "conversionTracking",
-    type: "group",
-    label: "Conversion Tracking",
-    admin: {
-      position: sidebar ? "sidebar" : void 0,
-      description: "Configure conversion tracking for analytics"
-    },
-    fields: [
-      {
-        name: "isConversionPage",
-        type: "checkbox",
-        label: "Is Conversion Page",
-        defaultValue: false,
-        admin: {
-          description: "Check this if this page represents a completed conversion (e.g., thank you page)"
-        }
-      },
-      {
-        name: "conversionType",
-        type: "select",
-        label: "Conversion Type",
-        options: conversionTypes,
-        admin: {
-          description: "Type of conversion this page represents",
-          condition: (data, siblingData) => siblingData?.isConversionPage === true
-        }
-      },
-      {
-        name: "conversionValue",
-        type: "number",
-        label: "Conversion Value",
-        defaultValue: 0,
-        admin: {
-          description: "Monetary value of this conversion (0 for non-monetary conversions)",
-          condition: (data, siblingData) => siblingData?.isConversionPage === true
-        }
-      }
-    ]
-  };
-}
-var conversionFieldGroup = createConversionFieldGroup();
-function getPuckFields(options = {}) {
-  const {
-    includeSEO = true,
-    includeConversion = false,
-    includeEditorVersion = true,
-    includePageLayout = true,
-    includeIsHomepage = false,
-    layouts = DEFAULT_LAYOUTS,
-    defaultEditorVersion = "puck",
-    legacyBlocksFieldName = "layout",
-    sidebarPosition = true,
-    conversionTypeOptions
-  } = options;
-  const fields = [];
-  fields.push(puckDataField);
-  if (includeEditorVersion) {
-    fields.push(createEditorVersionField(defaultEditorVersion, sidebarPosition, legacyBlocksFieldName));
-  }
-  if (includePageLayout) {
-    fields.push(createPageLayoutField(layouts, sidebarPosition));
-  }
-  if (includeIsHomepage) {
-    fields.push(isHomepageField);
-  }
-  if (includeSEO) {
-    fields.push(seoFieldGroup);
-  }
-  if (includeConversion) {
-    fields.push(createConversionFieldGroup(conversionTypeOptions, sidebarPosition));
-  }
-  return fields;
-}
-
-// src/plugin/collections/Pages.ts
-var defaultAccess = () => true;
-function generatePagesCollection(slug, options) {
-  const {
-    collectionOverrides = {},
-    access = {},
-    layouts = DEFAULT_LAYOUTS,
-    additionalFields = []
-  } = options;
-  const baseFields = [
-    // Core Fields (title and slug with duplication hooks - unique to collection generation)
-    {
-      name: "title",
-      type: "text",
-      required: true,
-      hooks: {
-        beforeDuplicate: [
-          ({ value }) => {
-            if (!value) return value;
-            const copyMatch = value.match(/^(.+) \(Copy(?: (\d+))?\)$/);
-            if (copyMatch) {
-              const baseName = copyMatch[1];
-              const copyNum = copyMatch[2] ? parseInt(copyMatch[2], 10) + 1 : 2;
-              return `${baseName} (Copy ${copyNum})`;
+import { generatePagesCollection } from './collections/Pages';
+import { TemplatesCollection } from '../collections/Templates';
+import { getPuckFields } from './fields';
+import { createListHandler, createCreateHandler, createGetHandler, createUpdateHandler, createDeleteHandler, createVersionsHandler, createRestoreHandler, } from '../endpoints/index.js';
+/**
+ * Get all field names from a collection's fields array (including nested group fields and tabs)
+ */
+function getExistingFieldNames(fields) {
+    const names = new Set();
+    function addFieldNames(fieldsToCheck) {
+        for (const field of fieldsToCheck) {
+            // Add the field name if it has one
+            if ('name' in field && field.name) {
+                names.add(field.name);
             }
-            return `${value} (Copy)`;
-          }
-        ]
-      }
-    },
-    {
-      name: "slug",
-      type: "text",
-      required: true,
-      unique: true,
-      index: true,
-      admin: {
-        position: "sidebar",
-        description: "URL path for this page (auto-generated from title)"
-      },
-      hooks: {
-        beforeValidate: [
-          ({ data, value }) => {
-            if (data && !value && data.title) {
-              return data.title.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").trim();
+            // Check nested fields in groups, rows, collapsibles, etc.
+            if ('fields' in field && Array.isArray(field.fields)) {
+                addFieldNames(field.fields);
             }
-            return value;
-          }
-        ],
-        beforeDuplicate: [
-          ({ value }) => {
-            if (!value) return value;
-            const copyMatch = value.match(/^(.+)-copy(?:-(\d+))?$/);
-            if (copyMatch) {
-              const baseName = copyMatch[1];
-              const copyNum = copyMatch[2] ? parseInt(copyMatch[2], 10) + 1 : 2;
-              return `${baseName}-copy-${copyNum}`;
+            // Check fields inside tabs
+            if (field.type === 'tabs' && 'tabs' in field && Array.isArray(field.tabs)) {
+                for (const tab of field.tabs) {
+                    if ('fields' in tab && Array.isArray(tab.fields)) {
+                        addFieldNames(tab.fields);
+                    }
+                }
             }
-            return `${value}-copy`;
-          }
-        ]
-      }
-    },
-    // Page Layout
-    createPageLayoutField(layouts, true),
-    // Editor Version
-    createEditorVersionField("puck", true),
-    // Homepage Flag
-    isHomepageField,
-    // Puck Data (hidden - managed via visual editor)
-    puckDataField,
-    // SEO Fields
-    seoFieldGroup,
-    // Conversion Tracking Fields
-    conversionFieldGroup,
-    // Additional fields from options
-    ...additionalFields
-  ];
-  return {
-    slug,
-    admin: {
-      useAsTitle: "title",
-      group: "Content",
-      defaultColumns: ["title", "slug", "_status", "updatedAt"],
-      ...collectionOverrides.admin ?? {}
-    },
-    access: {
-      read: access.read ?? defaultAccess,
-      create: access.create ?? defaultAccess,
-      update: access.update ?? defaultAccess,
-      delete: access.delete ?? defaultAccess,
-      ...collectionOverrides.access ?? {}
-    },
-    versions: typeof collectionOverrides.versions === "object" ? { drafts: true, ...collectionOverrides.versions } : { drafts: true },
-    fields: baseFields,
-    ...collectionOverrides,
-    // Ensure fields aren't overwritten by collectionOverrides
-    ...collectionOverrides.fields && {
-      fields: [...baseFields, ...collectionOverrides.fields]
-    }
-  };
-}
-
-// src/collections/Templates.ts
-var TemplatesCollection = {
-  slug: "puck-templates",
-  admin: {
-    useAsTitle: "name",
-    group: "Puck",
-    defaultColumns: ["name", "category", "updatedAt"],
-    description: "Reusable component templates for the visual editor"
-  },
-  access: {
-    read: () => true,
-    create: ({ req }) => !!req.user,
-    update: ({ req }) => !!req.user,
-    delete: ({ req }) => !!req.user
-  },
-  fields: [
-    {
-      name: "name",
-      type: "text",
-      required: true,
-      admin: {
-        description: "A descriptive name for this template"
-      }
-    },
-    {
-      name: "description",
-      type: "textarea",
-      admin: {
-        description: "Optional description of what this template contains"
-      }
-    },
-    {
-      name: "category",
-      type: "text",
-      admin: {
-        description: 'Category for organizing templates (e.g., "Hero", "Footer", "CTA")'
-      }
-    },
-    {
-      name: "content",
-      type: "json",
-      required: true,
-      admin: {
-        description: "Serialized Puck component data"
-      }
-    },
-    {
-      name: "thumbnail",
-      type: "text",
-      admin: {
-        description: "Optional thumbnail URL for template preview"
-      }
-    }
-  ],
-  timestamps: true
-};
-
-// src/plugin/index.ts
-function getExistingFieldNames(fields) {
-  const names = /* @__PURE__ */ new Set();
-  function addFieldNames(fieldsToCheck) {
-    for (const field of fieldsToCheck) {
-      if ("name" in field && field.name) {
-        names.add(field.name);
-      }
-      if ("fields" in field && Array.isArray(field.fields)) {
-        addFieldNames(field.fields);
-      }
-      if (field.type === "tabs" && "tabs" in field && Array.isArray(field.tabs)) {
-        for (const tab of field.tabs) {
-          if ("fields" in tab && Array.isArray(tab.fields)) {
-            addFieldNames(tab.fields);
-          }
         }
-      }
     }
-  }
-  addFieldNames(fields);
-  return names;
+    addFieldNames(fields);
+    return names;
 }
+/**
+ * Filter out fields that already exist in the target collection
+ */
 function filterExistingFields(fieldsToAdd, existingNames) {
-  return fieldsToAdd.filter((field) => {
-    if ("name" in field && field.name) {
-      return !existingNames.has(field.name);
-    }
-    return true;
-  });
+    return fieldsToAdd.filter((field) => {
+        if ('name' in field && field.name) {
+            return !existingNames.has(field.name);
+        }
+        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 = "Edit with Puck",
-    buttonPosition
-    // undefined = main area (default), 'sidebar' = sidebar
-  } = adminConfig;
-  return {
-    name: "puckEdit",
-    type: "ui",
-    admin: {
-      // Only set position if explicitly specified (sidebar)
-      // undefined means main form area in Payload
-      ...buttonPosition && { position: buttonPosition },
-      components: {
-        Field: "@delmaredigital/payload-puck/admin/client#EditWithPuckButton",
-        Cell: "@delmaredigital/payload-puck/admin/client#EditWithPuckCell"
-      },
-      custom: {
-        collectionSlug,
-        editorPathPattern,
-        label: buttonLabel
-      }
-    }
-  };
+    const { editorPathPattern = '/pages/{id}/edit', buttonLabel = 'Edit with Puck', buttonPosition, // undefined = main area (default), 'sidebar' = sidebar
+     } = adminConfig;
+    return {
+        name: 'puckEdit',
+        type: 'ui',
+        admin: {
+            // Only set position if explicitly specified (sidebar)
+            // undefined means main form area in Payload
+            ...(buttonPosition && { position: buttonPosition }),
+            components: {
+                Field: '@delmaredigital/payload-puck/admin/client#EditWithPuckButton',
+                Cell: '@delmaredigital/payload-puck/admin/client#EditWithPuckCell',
+            },
+            custom: {
+                collectionSlug,
+                editorPathPattern,
+                label: buttonLabel,
+            },
+        },
+    };
 }
-function createPuckPlugin(options = {}) {
-  const {
-    pagesCollection = "pages",
-    autoGenerateCollection = true,
-    admin: adminConfig = {}
-  } = options;
-  const { addEditButton = true } = adminConfig;
-  return (incomingConfig) => {
-    let collections = incomingConfig.collections || [];
-    const templatesCollectionExists = collections.some(
-      (c) => c.slug === "puck-templates"
-    );
-    if (!templatesCollectionExists) {
-      collections = [...collections, TemplatesCollection];
+/**
+ * Creates a Payload plugin that integrates Puck visual page builder
+ *
+ * This plugin:
+ * - Generates a Pages collection with puckData field
+ * - Registers the Puck editor as an admin view at /admin/puck-editor/:collection/:id
+ * - Adds an "Edit with Puck" button in the admin document view
+ * - Optionally registers API endpoints for CRUD operations
+ *
+ * The Puck editor is fully integrated into Payload's admin UI.
+ *
+ * @example
+ * ```typescript
+ * import { createPuckPlugin } from '@delmaredigital/payload-puck/plugin'
+ *
+ * export default buildConfig({
+ *   plugins: [
+ *     createPuckPlugin({
+ *       pagesCollection: 'pages',
+ *       access: {
+ *         read: () => true,
+ *         create: ({ req }) => !!req.user,
+ *         update: ({ req }) => !!req.user,
+ *         delete: ({ req }) => req.user?.role === 'admin',
+ *       },
+ *       admin: {
+ *         buttonLabel: 'Visual Editor',
+ *       },
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+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
+     } = options;
+    const { addEditButton = true } = pluginAdminConfig;
+    // Parse page-tree integration config
+    // - undefined: auto-detect at runtime (null stored, view will check for pageSegment field)
+    // - false: explicitly disabled (store false to prevent auto-detection)
+    // - true: use defaults
+    // - object: use custom field names
+    let pageTreeConfig = null;
+    if (pageTreeIntegration === undefined) {
+        // Not specified - store null to trigger auto-detection in the view
+        pageTreeConfig = null;
     }
-    if (autoGenerateCollection) {
-      const existingCollectionIndex = collections.findIndex(
-        (c) => c.slug === pagesCollection
-      );
-      const editButtonField = addEditButton ? [generatePuckEditField(pagesCollection, adminConfig)] : [];
-      if (existingCollectionIndex >= 0) {
-        const existingCollection = collections[existingCollectionIndex];
-        const existingFields = existingCollection.fields || [];
-        const existingFieldNames = getExistingFieldNames(existingFields);
-        const puckFields = getPuckFields({
-          includeSEO: !existingFieldNames.has("meta"),
-          includeConversion: !existingFieldNames.has("conversionTracking"),
-          includeEditorVersion: !existingFieldNames.has("editorVersion"),
-          includePageLayout: !existingFieldNames.has("pageLayout"),
-          includeIsHomepage: !existingFieldNames.has("isHomepage"),
-          layouts: options.layouts
-        });
-        const fieldsToAdd = filterExistingFields(puckFields, existingFieldNames);
-        const editFieldsToAdd = existingFieldNames.has("puckEdit") ? [] : editButtonField;
-        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 },
-            fields: [
-              ...existingFields,
-              ...fieldsToAdd,
-              ...editFieldsToAdd
-            ]
-          },
-          ...collections.slice(existingCollectionIndex + 1)
-        ];
-      } else {
-        const generatedCollection = generatePagesCollection(pagesCollection, options);
-        collections = [
-          ...collections,
-          {
-            ...generatedCollection,
-            fields: [...generatedCollection.fields, ...editButtonField]
-          }
-        ];
-      }
+    else if (pageTreeIntegration === false) {
+        // Explicitly disabled - store false to prevent auto-detection
+        pageTreeConfig = false;
     }
-    return {
-      ...incomingConfig,
-      collections,
-      onInit: async (payload) => {
-        if (incomingConfig.onInit) {
-          await incomingConfig.onInit(payload);
+    else if (pageTreeIntegration === true) {
+        // Explicitly enabled with defaults
+        pageTreeConfig = {
+            folderSlug: 'payload-folders',
+            segmentFieldName: 'pathSegment',
+            pageSegmentFieldName: 'pageSegment',
+            folderFieldName: 'folder',
+        };
+    }
+    else {
+        // Custom config object
+        pageTreeConfig = {
+            folderSlug: pageTreeIntegration.folderSlug ?? 'payload-folders',
+            segmentFieldName: pageTreeIntegration.segmentFieldName ?? 'pathSegment',
+            pageSegmentFieldName: pageTreeIntegration.pageSegmentFieldName ?? 'pageSegment',
+            folderFieldName: pageTreeIntegration.folderFieldName ?? 'folder',
+        };
+    }
+    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');
+        if (!templatesCollectionExists) {
+            collections = [...collections, TemplatesCollection];
+        }
+        if (autoGenerateCollection) {
+            // Check if collection already exists
+            const existingCollectionIndex = collections.findIndex((c) => c.slug === pagesCollection);
+            // Generate the edit button field if enabled
+            const editButtonField = addEditButton
+                ? [generatePuckEditField(pagesCollection, pluginAdminConfig)]
+                : [];
+            if (existingCollectionIndex >= 0) {
+                // Collection exists - only add Puck fields that don't already exist
+                const existingCollection = collections[existingCollectionIndex];
+                const existingFields = existingCollection.fields || [];
+                const existingFieldNames = getExistingFieldNames(existingFields);
+                // Get Puck-specific fields (not the full collection with title/slug)
+                // This avoids duplicating fields the user may have already defined
+                const puckFields = getPuckFields({
+                    includeSEO: !existingFieldNames.has('meta'),
+                    includeConversion: !existingFieldNames.has('conversionTracking'),
+                    includeEditorVersion: !existingFieldNames.has('editorVersion'),
+                    includePageLayout: !existingFieldNames.has('pageLayout'),
+                    includeIsHomepage: !existingFieldNames.has('isHomepage'),
+                    layouts: options.layouts,
+                });
+                // Filter out any remaining duplicates (e.g., puckData if user already has it)
+                const fieldsToAdd = filterExistingFields(puckFields, existingFieldNames);
+                // Only add edit button if puckEdit doesn't exist
+                const editFieldsToAdd = existingFieldNames.has('puckEdit') ? [] : editButtonField;
+                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 },
+                        fields: [
+                            ...existingFields,
+                            ...fieldsToAdd,
+                            ...editFieldsToAdd,
+                        ],
+                    },
+                    ...collections.slice(existingCollectionIndex + 1),
+                ];
+            }
+            else {
+                // Add new collection with edit button field
+                const generatedCollection = generatePagesCollection(pagesCollection, options);
+                collections = [
+                    ...collections,
+                    {
+                        ...generatedCollection,
+                        fields: [...generatedCollection.fields, ...editButtonField],
+                    },
+                ];
+            }
         }
-      }
+        // Build the admin config with view registration
+        const payloadAdminConfig = {
+            ...incomingConfig.admin,
+        };
+        // Register the Puck editor admin view if enabled
+        if (enableAdminView) {
+            payloadAdminConfig.components = {
+                ...payloadAdminConfig.components,
+                views: {
+                    ...payloadAdminConfig.components?.views,
+                    puckEditor: {
+                        Component: '@delmaredigital/payload-puck/rsc#PuckEditorView',
+                        path: `${adminViewPath}/:segments*`,
+                    },
+                },
+            };
+        }
+        // Register API endpoints if enabled
+        const puckCollections = [pagesCollection];
+        const endpointOptions = { collections: puckCollections };
+        const endpoints = enableEndpoints
+            ? [
+                ...(incomingConfig.endpoints || []),
+                {
+                    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,
+            collections,
+            endpoints,
+            // Store options in custom for the view to access
+            custom: {
+                ...incomingConfig.custom,
+                puck: {
+                    collections: puckCollections,
+                    layouts: options.layouts,
+                    // Page-tree integration config (null if not enabled)
+                    pageTree: pageTreeConfig,
+                },
+            },
+            onInit: async (payload) => {
+                // Call existing onInit if present
+                if (incomingConfig.onInit) {
+                    await incomingConfig.onInit(payload);
+                }
+            },
+        };
     };
-  };
 }
-
-exports.TemplatesCollection = TemplatesCollection;
-exports.conversionFieldGroup = conversionFieldGroup;
-exports.createEditorVersionField = createEditorVersionField;
-exports.createPageLayoutField = createPageLayoutField;
-exports.createPuckPlugin = createPuckPlugin;
-exports.editorVersionField = editorVersionField;
-exports.generatePagesCollection = generatePagesCollection;
-exports.generatePuckEditField = generatePuckEditField;
-exports.getPuckFields = getPuckFields;
-exports.isHomepageField = isHomepageField;
-exports.pageLayoutField = pageLayoutField;
-exports.puckDataField = puckDataField;
-exports.seoFieldGroup = seoFieldGroup;
-//# sourceMappingURL=index.js.map
+// Re-export collection utilities
+export { generatePagesCollection } from './collections/Pages';
+export { TemplatesCollection } from '../collections/Templates';
+// Re-export field utilities for hybrid collection integration
+export { getPuckFields, puckDataField, editorVersionField, createEditorVersionField, pageLayoutField, createPageLayoutField, isHomepageField, seoFieldGroup, conversionFieldGroup, } from './fields';
+// Export the edit button generator for hybrid collections
+export { generatePuckEditField };
 //# sourceMappingURL=index.js.map