canopycms 0.0.67-int.90 → 0.0.67

package/dist/editor/permission-manager/hooks/useGroupsAndUsers.js

@@ -1,21 +1,15 @@
-/**
- * Hook for managing groups and user search state
- */
 import { useState, useEffect, useMemo, useCallback } from 'react';
 export function useGroupsAndUsers({ onListGroups, onSearchUsers, canEdit, }) {
-    // Groups state
     const [groups, setGroups] = useState([]);
     const [isLoadingGroups, setIsLoadingGroups] = useState(false);
     const [groupLoadError, setGroupLoadError] = useState(null);
     const [groupSearchQuery, setGroupSearchQuery] = useState('');
     const [showGroupSearch, setShowGroupSearch] = useState(false);
-    // User search state
     const [userSearchResults, setUserSearchResults] = useState([]);
     const [isSearchingUsers, setIsSearchingUsers] = useState(false);
     const [userSearchQuery, setUserSearchQuery] = useState('');
     const [showUserSearch, setShowUserSearch] = useState(false);
     const [userSearchError, setUserSearchError] = useState(null);
-    // Load groups on mount
     useEffect(() => {
         if (onListGroups && canEdit) {
             setIsLoadingGroups(true);
@@ -31,13 +25,11 @@ export function useGroupsAndUsers({ onListGroups, onSearchUsers, canEdit, }) {
                 .finally(() => setIsLoadingGroups(false));
         }
     }, [onListGroups, canEdit]);
-    // Transform groups to select data format
     const groupSelectData = useMemo(() => groups.map((g) => ({
         value: g.id,
         label: g.name,
         source: g.source,
     })), [groups]);
-    // Filter groups based on search query
     const filteredGroups = useMemo(() => {
         const query = groupSearchQuery.toLowerCase().trim();
         if (!query)
@@ -79,7 +71,6 @@ export function useGroupsAndUsers({ onListGroups, onSearchUsers, canEdit, }) {
         setGroupLoadError(null);
     }, []);
     return {
-        // Groups
         groups,
         groupSelectData,
         filteredGroups,
@@ -90,7 +81,6 @@ export function useGroupsAndUsers({ onListGroups, onSearchUsers, canEdit, }) {
         setGroupSearchQuery,
         setShowGroupSearch,
         clearGroupLoadError,
-        // Users
         userSearchResults,
         isSearchingUsers,
         userSearchQuery,

package/dist/editor/permission-manager/hooks/usePermissionTree.d.ts

@@ -1,6 +1,3 @@
-/**
- * Hook for managing permission tree state and operations
- */
 import type { TreeNode, ContentNode, PathPermission, PermissionLevel, PermissionTarget } from '../types.js';
 import type { EditorCollection } from '../../Editor.js';
 export interface UsePermissionTreeOptions {
@@ -10,29 +7,18 @@ export interface UsePermissionTreeOptions {
     contentTree?: ContentNode;
 }
 export interface UsePermissionTreeResult {
-    /** The annotated tree with permissions */
     annotatedTree: TreeNode;
-    /** Expanded node paths */
     expandedNodes: Set<string>;
-    /** Currently selected node path */
     selectedNode: string | null;
     /** Local permission state (may differ from saved) */
     localPermissions: PathPermission[];
-    /** Whether there are unsaved changes */
     isDirty: boolean;
-    /** Toggle a node's expanded state */
     toggleNode: (path: string) => void;
-    /** Expand all nodes */
     expandAll: () => void;
-    /** Collapse all nodes */
     collapseAll: () => void;
-    /** Select a node */
     selectNode: (path: string | null) => void;
-    /** Update permission for a node */
     updateNodePermission: (nodePath: string, level: PermissionLevel, updates: Partial<PermissionTarget>) => void;
-    /** Reset local permissions to saved state */
     resetPermissions: () => void;
-    /** Set dirty state */
     setIsDirty: (dirty: boolean) => void;
     /** Set local permissions directly (for after save) */
     setLocalPermissions: React.Dispatch<React.SetStateAction<PathPermission[]>>;

package/dist/editor/permission-manager/hooks/usePermissionTree.js

@@ -1,6 +1,3 @@
-/**
- * Hook for managing permission tree state and operations
- */
 import { useState, useMemo, useEffect, useCallback } from 'react';
 import { buildTree, annotateTreeWithPermissions, findTreeNode } from '../utils.js';
 import { parsePermissionPath } from '../../../authorization/validation.js';
@@ -9,11 +6,8 @@ export function usePermissionTree({ collections, contentRoot = 'content', permis
     const [selectedNode, setSelectedNode] = useState(null);
     const [localPermissions, setLocalPermissions] = useState(permissions);
     const [isDirty, setIsDirty] = useState(false);
-    // Build tree from collections + contentTree
     const tree = useMemo(() => buildTree(contentTree, contentRoot, collections), [collections, contentTree, contentRoot]);
-    // Annotate tree with permissions
     const annotatedTree = useMemo(() => annotateTreeWithPermissions(tree, localPermissions), [tree, localPermissions]);
-    // Reset local state when permissions change externally
     useEffect(() => {
         setLocalPermissions(permissions);
         setIsDirty(false);
@@ -61,18 +55,15 @@ export function usePermissionTree({ collections, contentRoot = 'content', permis
             const permissionPath = parsed.path;
             const existingIndex = newPermissions.findIndex((p) => p.path === permissionPath);
             if (existingIndex >= 0) {
-                // Update existing permission for this level
                 const existing = newPermissions[existingIndex];
                 const updatedLevel = {
                     ...existing[level],
                     ...updates,
                 };
-                // Clean up empty arrays
                 if (updatedLevel.allowedUsers?.length === 0)
                     delete updatedLevel.allowedUsers;
                 if (updatedLevel.allowedGroups?.length === 0)
                     delete updatedLevel.allowedGroups;
-                // If level target is empty, remove it
                 if (!updatedLevel.allowedUsers && !updatedLevel.allowedGroups) {
                     newPermissions[existingIndex] = { ...existing, [level]: undefined };
                 }
@@ -82,14 +73,12 @@ export function usePermissionTree({ collections, contentRoot = 'content', permis
                         [level]: updatedLevel,
                     };
                 }
-                // If all levels are empty, remove the permission entirely
                 const perm = newPermissions[existingIndex];
                 if (!perm.read && !perm.edit && !perm.review) {
                     newPermissions.splice(existingIndex, 1);
                 }
             }
             else {
-                // Add new permission
                 if (updates.allowedUsers?.length || updates.allowedGroups?.length) {
                     newPermissions.push({
                         path: permissionPath,

package/dist/editor/permission-manager/index.d.ts

@@ -1,10 +1,3 @@
-/**
- * PermissionManager - Main component for managing path-based permissions.
- *
- * This component provides a tree-based UI for configuring read/edit/review
- * permissions on content paths. Supports both schema-based and collection-based
- * tree building.
- */
 import React from 'react';
 import type { PermissionManagerProps } from './types.js';
 export declare const PermissionManager: React.FC<PermissionManagerProps>;

package/dist/editor/permission-manager/index.js

@@ -1,12 +1,5 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * PermissionManager - Main component for managing path-based permissions.
- *
- * This component provides a tree-based UI for configuring read/edit/review
- * permissions on content paths. Supports both schema-based and collection-based
- * tree building.
- */
 import { useState, useCallback } from 'react';
 import { Alert, Button, Group, Loader, ScrollArea, Stack, Text } from '@mantine/core';
 import { IconAlertCircle } from '@tabler/icons-react';
@@ -18,20 +11,17 @@ export const PermissionManager = ({ collections, contentRoot = 'content', permis
     const [isSaving, setIsSaving] = useState(false);
     const [error, setError] = useState(null);
     const [activeLevel, setActiveLevel] = useState('read');
-    // Tree state management
     const { annotatedTree, expandedNodes, selectedNode, localPermissions, isDirty, toggleNode, expandAll, collapseAll, selectNode, updateNodePermission, resetPermissions, setIsDirty, } = usePermissionTree({
         collections,
         contentRoot,
         permissions,
         contentTree,
     });
-    // Groups and user search
     const { groupSelectData, filteredGroups, groupLoadError, groupSearchQuery, showGroupSearch, setGroupSearchQuery, setShowGroupSearch, clearGroupLoadError, userSearchResults, isSearchingUsers, userSearchQuery, showUserSearch, userSearchError, setUserSearchQuery, toggleUserSearch, } = useGroupsAndUsers({
         onListGroups,
         onSearchUsers,
         canEdit,
     });
-    // Save handler
     const handleSave = useCallback(async () => {
         if (!onSave)
             return;
@@ -48,12 +38,10 @@ export const PermissionManager = ({ collections, contentRoot = 'content', permis
             setIsSaving(false);
         }
     }, [onSave, localPermissions, setIsDirty]);
-    // Discard handler
     const handleDiscard = useCallback(() => {
         resetPermissions();
         setError(null);
     }, [resetPermissions]);
-    // User add handler with search state cleanup
     const handleAddUser = useCallback((nodePath, level, userId) => {
         const treeNode = findTreeNode(annotatedTree, nodePath);
         const permissionPath = treeNode?.type === 'folder' ? `${nodePath}/**` : nodePath;
@@ -66,11 +54,9 @@ export const PermissionManager = ({ collections, contentRoot = 'content', permis
                 allowedGroups: currentTarget?.allowedGroups,
             });
         }
-        // Clear search state
         setUserSearchQuery('');
         toggleUserSearch(false);
     }, [annotatedTree, localPermissions, updateNodePermission, setUserSearchQuery, toggleUserSearch]);
-    // User remove handler
     const handleRemoveUser = useCallback((nodePath, level, userId) => {
         const treeNode = findTreeNode(annotatedTree, nodePath);
         const permissionPath = treeNode?.type === 'folder' ? `${nodePath}/**` : nodePath;
@@ -83,7 +69,6 @@ export const PermissionManager = ({ collections, contentRoot = 'content', permis
             allowedGroups: currentTarget.allowedGroups,
         });
     }, [annotatedTree, localPermissions, updateNodePermission]);
-    // Group add handler
     const handleAddGroup = useCallback((nodePath, level, groupId) => {
         const treeNode = findTreeNode(annotatedTree, nodePath);
         const permissionPath = treeNode?.type === 'folder' ? `${nodePath}/**` : nodePath;
@@ -105,7 +90,6 @@ export const PermissionManager = ({ collections, contentRoot = 'content', permis
         setGroupSearchQuery,
         setShowGroupSearch,
     ]);
-    // Group remove handler
     const handleRemoveGroup = useCallback((nodePath, level, groupId) => {
         const treeNode = findTreeNode(annotatedTree, nodePath);
         const permissionPath = treeNode?.type === 'folder' ? `${nodePath}/**` : nodePath;

package/dist/editor/permission-manager/types.d.ts

@@ -1,29 +1,20 @@
-/**
- * Types for PermissionManager component
- */
 import type { PathPermission, PermissionLevel, PermissionTarget } from '../../config/index.js';
-import type { UserSearchResult, GroupMetadata, GroupSource, PermissionGroupOption } from '../../auth/types.js';
+import type { UserSearchResult, GroupSource, PermissionGroupOption } from '../../auth/types.js';
 import type { EditorCollection } from '../Editor.js';
 export interface PermissionManagerProps {
     /** Collections from API */
     collections?: EditorCollection[];
     /** Content root path (default: 'content') */
     contentRoot?: string;
-    /** Current permissions */
     permissions: PathPermission[];
     /** Whether user can edit permissions (admin only) */
     canEdit: boolean;
-    /** Handler to save updated permissions */
     onSave?: (permissions: PathPermission[]) => Promise<void>;
-    /** Handler to search users */
     onSearchUsers?: (query: string, limit?: number) => Promise<UserSearchResult[]>;
-    /** Handler to get user metadata by ID */
     onGetUserMetadata?: (userId: string) => Promise<UserSearchResult | null>;
     /** Handler to list groups (internal + external, tagged by `source`) */
     onListGroups?: () => Promise<PermissionGroupOption[]>;
-    /** Close handler */
     onClose?: () => void;
-    /** Loading state */
     loading?: boolean;
     /** Optional: actual filesystem content tree (for entries not in schema) */
     contentTree?: ContentNode;
@@ -50,5 +41,4 @@ export interface GroupSelectItem {
     /** Which universe this option came from; shown as a tag in the picker. */
     source: GroupSource;
 }
-/** Re-export for convenience */
-export type { PathPermission, PermissionLevel, PermissionTarget, UserSearchResult, GroupMetadata, GroupSource, PermissionGroupOption, };
+export type { PathPermission, PermissionLevel, PermissionTarget, UserSearchResult, GroupSource, PermissionGroupOption, };

package/dist/editor/permission-manager/types.js

@@ -1,4 +1 @@
-/**
- * Types for PermissionManager component
- */
 export {};

package/dist/editor/permission-manager/utils.d.ts

@@ -1,41 +1,13 @@
-/**
- * Utility functions for PermissionManager
- */
 import type { TreeNode, ContentNode, PathPermission } from './types.js';
 import type { EditorCollection } from '../Editor.js';
 /**
  * Search utility: Find a tree node by exact path match (recursive search).
- * Used to locate nodes when updating permissions.
  *
  * @param node - Root node to start searching from
  * @param path - The exact path to search for
  * @returns The matching TreeNode or null if not found
  */
 export declare function findTreeNode(node: TreeNode, path: string): TreeNode | null;
-/**
- * Transforms API/editor collections into permission tree nodes.
- *
- * Handles the case where buildEditorCollections returns a structure with the content root
- * as a top-level collection. Avoids double-wrapping by detecting when a collection IS the
- * content root itself and processing its children directly.
- *
- * @param collections - Array of EditorCollection from API or buildEditorCollections
- * @param contentRoot - The content root path (e.g., "content")
- * @param parentPath - Optional parent path for recursive calls
- * @returns Array of TreeNode for the permission tree
- */
-export declare function convertCollectionsToTreeNodes(collections: EditorCollection[], contentRoot: string, parentPath?: string): TreeNode[];
-/**
- * Merges filesystem content into schema tree for files not defined in the schema.
- *
- * Used to add files that exist in the filesystem but aren't explicitly defined in
- * the schema (e.g., entries created manually via the filesystem). Only adds files,
- * not folders - folders are expected to come from the schema.
- *
- * @param schemaNode - TreeNode from schema to merge into (mutated)
- * @param contentNode - Actual filesystem content tree from API
- */
-export declare function mergeContentTree(schemaNode: TreeNode, contentNode: ContentNode): void;
 /**
  * Build tree structure from EditorCollections.
  *

package/dist/editor/permission-manager/utils.js

@@ -1,9 +1,5 @@
-/**
- * Utility functions for PermissionManager
- */
 /**
  * Search utility: Find a tree node by exact path match (recursive search).
- * Used to locate nodes when updating permissions.
  *
  * @param node - Root node to start searching from
  * @param path - The exact path to search for
@@ -22,19 +18,16 @@ export function findTreeNode(node, path) {
 /**
  * Transforms API/editor collections into permission tree nodes.
  *
- * Handles the case where buildEditorCollections returns a structure with the content root
- * as a top-level collection. Avoids double-wrapping by detecting when a collection IS the
- * content root itself and processing its children directly.
+ * Skips wrapping when `collections` is a single item that IS the content root
+ * itself (as `buildEditorCollections` returns), processing its children
+ * directly instead of double-nesting.
  *
  * @param collections - Array of EditorCollection from API or buildEditorCollections
  * @param contentRoot - The content root path (e.g., "content")
  * @param parentPath - Optional parent path for recursive calls
  * @returns Array of TreeNode for the permission tree
  */
-export function convertCollectionsToTreeNodes(collections, contentRoot, parentPath) {
-    // Special case: If we're at the top level (no parentPath) and the collections array
-    // contains exactly one item that IS the content root itself, skip creating a duplicate
-    // node for it and just process its children directly.
+function convertCollectionsToTreeNodes(collections, contentRoot, parentPath) {
     if (!parentPath && collections.length === 1 && collections[0].path === contentRoot) {
         const rootCollection = collections[0];
         return rootCollection.children
@@ -52,7 +45,6 @@ export function convertCollectionsToTreeNodes(collections, contentRoot, parentPa
             type: collection.type === 'collection' ? 'folder' : 'file',
             children: [],
         };
-        // Recursively process nested collections
         if (collection.children) {
             node.children = convertCollectionsToTreeNodes(collection.children, contentRoot, logicalPath);
         }
@@ -61,26 +53,24 @@ export function convertCollectionsToTreeNodes(collections, contentRoot, parentPa
     return nodes;
 }
 /**
- * Merges filesystem content into schema tree for files not defined in the schema.
+ * Merges filesystem content into the schema tree.
  *
- * Used to add files that exist in the filesystem but aren't explicitly defined in
- * the schema (e.g., entries created manually via the filesystem). Only adds files,
- * not folders - folders are expected to come from the schema.
+ * Adds files that exist in the filesystem but aren't defined in the schema
+ * (e.g., entries created manually), never folders — folders are expected to
+ * come from the schema.
  *
  * @param schemaNode - TreeNode from schema to merge into (mutated)
  * @param contentNode - Actual filesystem content tree from API
  */
-export function mergeContentTree(schemaNode, contentNode) {
+function mergeContentTree(schemaNode, contentNode) {
     contentNode.children?.forEach((child) => {
         const existing = schemaNode.children.find((n) => n.name === child.name);
         if (existing) {
-            // If this is a folder/collection that exists in schema, recursively merge its children
             if (child.type === 'folder' && child.children) {
                 mergeContentTree(existing, child);
             }
         }
         else if (child.type === 'file') {
-            // Add file not in schema (e.g., entry created via filesystem)
             schemaNode.children.push({
                 path: child.path,
                 name: child.name,
@@ -105,10 +95,8 @@ export function buildTree(contentTree, contentRoot = 'content', collections) {
         type: 'folder',
         children: [],
     };
-    // Build from collections if provided
     if (collections && collections.length > 0) {
         root.children = convertCollectionsToTreeNodes(collections, contentRoot);
-        // Merge contentTree if provided
         if (contentTree) {
             mergeContentTree(root, contentTree);
         }
@@ -128,9 +116,7 @@ export function buildTree(contentTree, contentRoot = 'content', collections) {
  */
 export function annotateTreeWithPermissions(node, permissions) {
     const folderPath = node.type === 'folder' ? `${node.path}/**` : node.path;
-    // Find direct permission
     const directPerm = permissions.find((p) => p.path === folderPath || p.path === node.path);
-    // Find inherited permission from parent
     let inheritedPerm;
     const pathParts = node.path.split('/');
     for (let i = pathParts.length - 1; i >= 0; i--) {

package/dist/editor/preview-bridge.d.ts

@@ -40,7 +40,7 @@ export interface HighlightMessage {
 }
 /**
  * Preview → editor report that the current draft fails to compile/render
- * (e.g. malformed MDX). `message: null` clears a previously reported error.
+ * (e.g. malformed MDX). `message: null` clears an earlier error.
  */
 export interface PreviewErrorMessage {
     type: typeof CANOPY_PREVIEW_ERROR;
@@ -48,6 +48,10 @@ export interface PreviewErrorMessage {
     message: string | null;
     fieldPath?: string;
 }
+/**
+ * Convenience hook that wires draft updates, focus emitter, and highlight toggling together.
+ * Returns live data plus helpers for setting data-canopy-path attributes.
+ */
 export declare const useCanopyPreview: <T>(opts: {
     path?: string;
     initialData: T;

package/dist/editor/preview-bridge.js

@@ -57,10 +57,6 @@ export const sendDraftUpdate = (iframe, message, targetOrigin) => {
         return;
     iframe.contentWindow.postMessage(message, target);
 };
-/**
- * Convenience hook that wires draft updates, focus emitter, and highlight toggling together.
- * Returns live data plus helpers for setting data-canopy-path attributes.
- */
 const resolvePreviewPath = (explicit) => {
     if (explicit)
         return explicit;
@@ -68,6 +64,10 @@ const resolvePreviewPath = (explicit) => {
         return '';
     return `${window.location.pathname}${window.location.search}`;
 };
+/**
+ * Convenience hook that wires draft updates, focus emitter, and highlight toggling together.
+ * Returns live data plus helpers for setting data-canopy-path attributes.
+ */
 export const useCanopyPreview = (opts) => {
     const resolvedPath = resolvePreviewPath(opts.path);
     const editorOrigin = opts.editorOrigin;

package/dist/editor/schema-editor/CollectionEditor.d.ts

@@ -26,7 +26,6 @@ export interface ExistingCollection {
     entries: ExistingEntryType[];
 }
 export interface CollectionEditorProps {
-    /** Whether the modal is open */
     isOpen: boolean;
     /** Collection being edited (null for create mode) */
     editingCollection: ExistingCollection | null;
@@ -42,12 +41,8 @@ export interface CollectionEditorProps {
     onUpdateEntryType?: (collectionPath: LogicalPath, entryTypeName: string, updates: Partial<CreateEntryTypeInput>) => Promise<SchemaOpResult>;
     /** Called when an entry type is removed (edit mode only) */
     onRemoveEntryType?: (collectionPath: LogicalPath, entryTypeName: string) => Promise<SchemaOpResult> | void;
-    /** Called when modal is closed */
     onClose: () => void;
-    /** Whether a save operation is in progress */
     isSaving?: boolean;
-    /** Error message to display */
     error?: string | null;
 }
 export declare function CollectionEditor({ isOpen, editingCollection, parentPath, availableSchemas, onSave, onAddEntryType, onUpdateEntryType, onRemoveEntryType, onClose, isSaving, error, }: CollectionEditorProps): import("react/jsx-runtime").JSX.Element;
-export default CollectionEditor;

package/dist/editor/schema-editor/CollectionEditor.js

@@ -3,13 +3,10 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 /**
  * CollectionEditor - Modal for creating/editing collections.
  *
- * Collections are containers for content items with:
- * - name: Machine-readable identifier (e.g., "posts", "pages")
- * - label: Human-readable display name
- * - entries: Array of entry types defining what content can be created
- *
- * When creating a collection, at least one entry type is required.
- * When editing, only name and label can be changed (entry types are managed separately).
+ * A collection has a name (machine-readable id), label (display name), and
+ * entries (entry types defining what content can be created). Create mode
+ * requires at least one entry type; edit mode only allows changing name and
+ * label (entry types are managed separately).
  */
 import { useState, useCallback, useEffect } from 'react';
 import { Modal, Stack, TextInput, Group, Button, Alert, Text, Paper, ActionIcon, Menu, Divider, Badge, } from '@mantine/core';
@@ -17,12 +14,8 @@ import { IconAlertCircle, IconPlus, IconDotsVertical, IconTrash, IconEdit, IconS
 import { EntryTypeEditor } from './EntryTypeEditor.js';
 import { ConfirmDeleteModal } from '../components/ConfirmDeleteModal.js';
 import { getErrorMessage } from '../../utils/error.js';
-// ============================================================================
-// Component
-// ============================================================================
 export function CollectionEditor({ isOpen, editingCollection, parentPath, availableSchemas, onSave, onAddEntryType, onUpdateEntryType, onRemoveEntryType, onClose, isSaving = false, error = null, }) {
     const isEditMode = editingCollection !== null;
-    // Form state
     const [formData, setFormData] = useState({
         name: '',
         label: '',
@@ -30,18 +23,14 @@ export function CollectionEditor({ isOpen, editingCollection, parentPath, availa
     });
     // Slug field state (edit mode only)
     const [slug, setSlug] = useState('');
-    // Local validation error
     const [validationError, setValidationError] = useState(null);
-    // Entry type editor state
     const [entryTypeEditorOpen, setEntryTypeEditorOpen] = useState(false);
     const [editingEntryType, setEditingEntryType] = useState(null);
     const [editingEntryTypeIndex, setEditingEntryTypeIndex] = useState(null);
     const [entryTypeSaving, setEntryTypeSaving] = useState(false);
     const [entryTypeError, setEntryTypeError] = useState(null);
-    // Delete entry type confirmation state
     const [deleteEntryTypeModalOpen, setDeleteEntryTypeModalOpen] = useState(false);
     const [deletingEntryType, setDeletingEntryType] = useState(null);
-    // Reset form when modal opens or editing item changes
     useEffect(() => {
         if (isOpen) {
             if (editingCollection) {
@@ -50,7 +39,7 @@ export function CollectionEditor({ isOpen, editingCollection, parentPath, availa
                     label: editingCollection.label || '',
                     entries: [], // Entry types are managed separately in edit mode
                 });
-                // Extract slug from logical path (e.g., "content/posts.abc123" -> "posts")
+                // Slug is the logical path's last segment before its embedded id (e.g. "posts.abc123" -> "posts").
                 const pathParts = editingCollection.logicalPath.split('/');
                 const lastPart = pathParts[pathParts.length - 1];
                 const slugPart = lastPart?.split('.')[0] || '';
@@ -67,19 +56,17 @@ export function CollectionEditor({ isOpen, editingCollection, parentPath, availa
             setValidationError(null);
         }
     }, [isOpen, editingCollection]);
-    // Update a form field
     const updateField = useCallback((field, value) => {
         setFormData((prev) => ({ ...prev, [field]: value }));
         setValidationError(null);
     }, []);
-    // Validate form
     const validate = useCallback(() => {
         if (!formData.name.trim()) {
             setValidationError('Name is required');
             return false;
         }
-        // Enforced in both create and edit mode (UI-M3): the server rejects
-        // unsafe names, but validate here for immediate feedback.
+        // Enforced in both create and edit mode: the server rejects unsafe
+        // names too, but this validates for immediate feedback.
         if (!/^[a-z][a-z0-9-]*$/.test(formData.name)) {
             setValidationError('Name must start with a letter and contain only lowercase letters, numbers, and hyphens');
             return false;
@@ -94,12 +81,10 @@ export function CollectionEditor({ isOpen, editingCollection, parentPath, availa
         }
         return true;
     }, [formData, isEditMode]);
-    // Handle save
     const handleSave = useCallback(() => {
         if (!validate())
             return;
         if (isEditMode) {
-            // Only include changed fields for update
             const updates = {};
             if (formData.name !== (editingCollection?.name || '')) {
                 updates.name = formData.name.trim() || undefined;
@@ -107,7 +92,6 @@ export function CollectionEditor({ isOpen, editingCollection, parentPath, availa
             if (formData.label !== (editingCollection?.label || '')) {
                 updates.label = formData.label || undefined;
             }
-            // Include slug if changed
             const pathParts = editingCollection?.logicalPath.split('/') || [];
             const lastPart = pathParts[pathParts.length - 1];
             const currentSlug = lastPart?.split('.')[0] || '';
@@ -117,7 +101,6 @@ export function CollectionEditor({ isOpen, editingCollection, parentPath, availa
             onSave(updates, false);
         }
         else {
-            // Create new collection
             const createData = {
                 name: formData.name.trim(),
                 entries: formData.entries,
@@ -131,7 +114,6 @@ export function CollectionEditor({ isOpen, editingCollection, parentPath, availa
             onSave(createData, true);
         }
     }, [formData, slug, isEditMode, editingCollection, parentPath, validate, onSave]);
-    // Entry type management (create mode)
     const handleOpenAddEntryType = useCallback(() => {
         setEditingEntryType(null);
         setEditingEntryTypeIndex(null);
@@ -146,7 +128,6 @@ export function CollectionEditor({ isOpen, editingCollection, parentPath, availa
     }, []);
     const handleEntryTypeSave = useCallback(async (data, isNew) => {
         if (isEditMode && editingCollection) {
-            // In edit mode, delegate to parent handlers
             setEntryTypeSaving(true);
             setEntryTypeError(null);
             try {
@@ -163,9 +144,8 @@ export function CollectionEditor({ isOpen, editingCollection, parentPath, availa
                 }
             }
             catch (err) {
-                // Genuine last resort: onAddEntryType/onUpdateEntryType return result
-                // objects by contract and are not expected to throw, but guard here
-                // in case a caller violates that contract.
+                // Last resort: onAddEntryType/onUpdateEntryType return result objects
+                // by contract and aren't expected to throw; guards a caller violating it.
                 setEntryTypeError(getErrorMessage(err));
                 return;
             }
@@ -219,7 +199,6 @@ export function CollectionEditor({ isOpen, editingCollection, parentPath, availa
         setDeleteEntryTypeModalOpen(false);
         setDeletingEntryType(null);
     }, [deletingEntryType, isEditMode, editingCollection, onRemoveEntryType]);
-    // Get entry types to display
     const displayEntryTypes = isEditMode
         ? editingCollection?.entries || []
         : formData.entries;
@@ -241,4 +220,3 @@ export function CollectionEditor({ isOpen, editingCollection, parentPath, availa
                     setDeletingEntryType(null);
                 } })] }));
 }
-export default CollectionEditor;

package/dist/editor/schema-editor/EntryTypeEditor.d.ts

@@ -9,7 +9,6 @@ export interface EntryTypeFormData {
     maxItems: number | undefined;
 }
 export interface EntryTypeEditorProps {
-    /** Whether the modal is open */
     isOpen: boolean;
     /** Entry type being edited (null for create mode) */
     editingEntryType: {
@@ -25,14 +24,9 @@ export interface EntryTypeEditorProps {
     availableSchemas: string[];
     /** Existing entry type names in the collection (for duplicate validation) */
     existingEntryTypeNames?: string[];
-    /** Called when save is clicked */
     onSave: (data: CreateEntryTypeInput | UpdateEntryTypeInput, isNew: boolean) => void;
-    /** Called when modal is closed */
     onClose: () => void;
-    /** Whether a save operation is in progress */
     isSaving?: boolean;
-    /** Error message to display */
     error?: string | null;
 }
 export declare function EntryTypeEditor({ isOpen, editingEntryType, availableSchemas, existingEntryTypeNames, onSave, onClose, isSaving, error, }: EntryTypeEditorProps): import("react/jsx-runtime").JSX.Element;
-export default EntryTypeEditor;