canopycms 0.0.0 → 0.0.2

package/src/editor/permission-manager/UserSelector.tsx

@@ -1,95 +0,0 @@
-'use client'
-
-/**
- * User search and selection component
- */
-
-import React from 'react'
-import { Paper, Stack, Text, Loader } from '@mantine/core'
-import type { UserSearchResult } from './types'
-import { UserBadge } from '../components/UserBadge'
-
-export interface UserSelectorProps {
-  searchQuery: string
-  onSearchChange: (query: string) => void
-  searchResults: UserSearchResult[]
-  isSearching: boolean
-  searchError: string | null
-  onSelectUser: (userId: string) => void
-  onGetUserMetadata?: (userId: string) => Promise<UserSearchResult | null>
-}
-
-export const UserSelector: React.FC<UserSelectorProps> = ({
-  searchQuery,
-  onSearchChange,
-  searchResults,
-  isSearching,
-  searchError,
-  onSelectUser,
-  onGetUserMetadata,
-}) => {
-  return (
-    <Paper withBorder p="sm" mt="xs">
-      <Stack gap="xs">
-        <input
-          type="text"
-          placeholder="Search users by name or email..."
-          value={searchQuery}
-          onChange={(e) => onSearchChange(e.target.value)}
-          aria-label="Search users by name or email"
-          style={{
-            width: '100%',
-            padding: '6px 8px',
-            border: '1px solid var(--mantine-color-gray-4)',
-            borderRadius: 'var(--mantine-radius-sm)',
-            fontSize: '14px',
-          }}
-        />
-        {isSearching && <Loader size="xs" />}
-        {searchError && (
-          <Text size="xs" c="red">
-            {searchError}
-          </Text>
-        )}
-        {searchResults.length > 0 && (
-          <Stack gap={4}>
-            {searchResults.map((user) => (
-              <Paper
-                key={user.id}
-                p="xs"
-                withBorder
-                style={{ cursor: 'pointer' }}
-                onClick={() => onSelectUser(user.id)}
-              >
-                {onGetUserMetadata ? (
-                  <UserBadge
-                    userId={user.id}
-                    getUserMetadata={onGetUserMetadata}
-                    variant="full"
-                    size="sm"
-                    cachedUser={user}
-                    showEmailTooltip={false}
-                  />
-                ) : (
-                  <>
-                    <Text size="sm" fw={500}>
-                      {user.name}
-                    </Text>
-                    <Text size="xs" c="dimmed">
-                      {user.email}
-                    </Text>
-                  </>
-                )}
-              </Paper>
-            ))}
-          </Stack>
-        )}
-        {searchQuery.trim() && !isSearching && searchResults.length === 0 && (
-          <Text size="xs" c="dimmed">
-            No users found
-          </Text>
-        )}
-      </Stack>
-    </Paper>
-  )
-}

package/src/editor/permission-manager/constants.tsx

@@ -1,18 +0,0 @@
-/**
- * Constants for PermissionManager
- */
-
-import React from 'react'
-import { IconEye, IconPencil, IconCheckbox } from '@tabler/icons-react'
-import type { PermissionLevel } from './types'
-
-export const PERMISSION_LEVELS: PermissionLevel[] = ['read', 'edit', 'review']
-
-export const LEVEL_CONFIG: Record<
-  PermissionLevel,
-  { label: string; icon: React.ReactNode; color: string }
-> = {
-  read: { label: 'Read', icon: <IconEye size={14} />, color: 'blue' },
-  edit: { label: 'Edit', icon: <IconPencil size={14} />, color: 'green' },
-  review: { label: 'Review', icon: <IconCheckbox size={14} />, color: 'grape' },
-}

package/src/editor/permission-manager/hooks/useGroupsAndUsers.ts

@@ -1,153 +0,0 @@
-/**
- * Hook for managing groups and user search state
- */
-
-import { useState, useEffect, useMemo, useCallback } from 'react'
-import type { UserSearchResult, GroupMetadata, GroupSelectItem } from '../types'
-
-export interface UseGroupsAndUsersOptions {
-  onListGroups?: () => Promise<GroupMetadata[]>
-  onSearchUsers?: (query: string, limit?: number) => Promise<UserSearchResult[]>
-  canEdit: boolean
-}
-
-export interface UseGroupsAndUsersResult {
-  // Groups
-  groups: GroupMetadata[]
-  groupSelectData: GroupSelectItem[]
-  filteredGroups: GroupSelectItem[]
-  isLoadingGroups: boolean
-  groupLoadError: string | null
-  groupSearchQuery: string
-  showGroupSearch: boolean
-  setGroupSearchQuery: (query: string) => void
-  setShowGroupSearch: (show: boolean) => void
-  clearGroupLoadError: () => void
-
-  // Users
-  userSearchResults: UserSearchResult[]
-  isSearchingUsers: boolean
-  userSearchQuery: string
-  showUserSearch: boolean
-  userSearchError: string | null
-  setUserSearchQuery: (query: string) => void
-  toggleUserSearch: (show: boolean) => void
-}
-
-export function useGroupsAndUsers({
-  onListGroups,
-  onSearchUsers,
-  canEdit,
-}: UseGroupsAndUsersOptions): UseGroupsAndUsersResult {
-  // Groups state
-  const [groups, setGroups] = useState<GroupMetadata[]>([])
-  const [isLoadingGroups, setIsLoadingGroups] = useState(false)
-  const [groupLoadError, setGroupLoadError] = useState<string | null>(null)
-  const [groupSearchQuery, setGroupSearchQuery] = useState('')
-  const [showGroupSearch, setShowGroupSearch] = useState(false)
-
-  // User search state
-  const [userSearchResults, setUserSearchResults] = useState<UserSearchResult[]>([])
-  const [isSearchingUsers, setIsSearchingUsers] = useState(false)
-  const [userSearchQuery, setUserSearchQuery] = useState('')
-  const [showUserSearch, setShowUserSearch] = useState(false)
-  const [userSearchError, setUserSearchError] = useState<string | null>(null)
-
-  // Load groups on mount
-  useEffect(() => {
-    if (onListGroups && canEdit) {
-      setIsLoadingGroups(true)
-      onListGroups()
-        .then((loadedGroups) => {
-          setGroups(loadedGroups)
-          setGroupLoadError(null)
-        })
-        .catch((err) => {
-          console.error('Failed to load groups:', err)
-          setGroupLoadError('Failed to load groups. Group selection may be unavailable.')
-        })
-        .finally(() => setIsLoadingGroups(false))
-    }
-  }, [onListGroups, canEdit])
-
-  // Transform groups to select data format
-  const groupSelectData = useMemo(
-    () =>
-      groups.map((g) => ({
-        value: g.id,
-        label: g.name,
-      })),
-    [groups],
-  )
-
-  // Filter groups based on search query
-  const filteredGroups = useMemo(() => {
-    const query = groupSearchQuery.toLowerCase().trim()
-    if (!query) return groupSelectData
-
-    return groupSelectData.filter(
-      (g) => g.label.toLowerCase().includes(query) || g.value.toLowerCase().includes(query),
-    )
-  }, [groupSearchQuery, groupSelectData])
-
-  // Debounced user search
-  useEffect(() => {
-    if (!showUserSearch || !userSearchQuery.trim()) return
-
-    const timer = setTimeout(() => {
-      if (onSearchUsers) {
-        setIsSearchingUsers(true)
-        setUserSearchError(null)
-        onSearchUsers(userSearchQuery, 10)
-          .then((results) => {
-            setUserSearchResults(results)
-            setUserSearchError(null)
-          })
-          .catch((err) => {
-            console.error('User search failed:', err)
-            setUserSearchError('Failed to search users. Please try again.')
-            setUserSearchResults([])
-          })
-          .finally(() => setIsSearchingUsers(false))
-      }
-    }, 300)
-
-    return () => clearTimeout(timer)
-  }, [userSearchQuery, onSearchUsers, showUserSearch])
-
-  const toggleUserSearch = useCallback((show: boolean) => {
-    setShowUserSearch(show)
-    if (!show) {
-      setUserSearchQuery('')
-      setUserSearchResults([])
-      setUserSearchError(null)
-    }
-  }, [])
-
-  const clearGroupLoadError = useCallback(() => {
-    setGroupLoadError(null)
-  }, [])
-
-  return {
-    // Groups
-    groups,
-    groupSelectData,
-    filteredGroups,
-    isLoadingGroups,
-    groupLoadError,
-    groupSearchQuery,
-    showGroupSearch,
-    setGroupSearchQuery,
-    setShowGroupSearch,
-    clearGroupLoadError,
-
-    // Users
-    userSearchResults,
-    isSearchingUsers,
-    userSearchQuery,
-    showUserSearch,
-    userSearchError,
-    setUserSearchQuery,
-    toggleUserSearch,
-  }
-}

package/src/editor/permission-manager/hooks/usePermissionTree.ts

@@ -1,200 +0,0 @@
-/**
- * Hook for managing permission tree state and operations
- */
-
-import { useState, useMemo, useEffect, useCallback } from 'react'
-import type {
-  TreeNode,
-  ContentNode,
-  PathPermission,
-  PermissionLevel,
-  PermissionTarget,
-} from '../types'
-import type { EditorCollection } from '../../Editor'
-import { buildTree, annotateTreeWithPermissions, findTreeNode } from '../utils'
-import { parsePermissionPath } from '../../../authorization/validation'
-
-export interface UsePermissionTreeOptions {
-  collections?: EditorCollection[]
-  contentRoot?: string
-  permissions: PathPermission[]
-  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[]>>
-}
-
-export function usePermissionTree({
-  collections,
-  contentRoot = 'content',
-  permissions,
-  contentTree,
-}: UsePermissionTreeOptions): UsePermissionTreeResult {
-  const [expandedNodes, setExpandedNodes] = useState<Set<string>>(new Set([contentRoot]))
-  const [selectedNode, setSelectedNode] = useState<string | null>(null)
-  const [localPermissions, setLocalPermissions] = useState<PathPermission[]>(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)
-  }, [permissions])
-
-  const toggleNode = useCallback((path: string) => {
-    setExpandedNodes((prev) => {
-      const next = new Set(prev)
-      if (next.has(path)) {
-        next.delete(path)
-      } else {
-        next.add(path)
-      }
-      return next
-    })
-  }, [])
-
-  const expandAll = useCallback(() => {
-    const allPaths = new Set<string>()
-    const collectPaths = (node: TreeNode) => {
-      if (node.type === 'folder') {
-        allPaths.add(node.path)
-      }
-      node.children.forEach(collectPaths)
-    }
-    collectPaths(annotatedTree)
-    setExpandedNodes(allPaths)
-  }, [annotatedTree])
-
-  const collapseAll = useCallback(() => {
-    setExpandedNodes(new Set())
-  }, [])
-
-  const selectNode = useCallback((path: string | null) => {
-    setSelectedNode(path)
-  }, [])
-
-  const updateNodePermission = useCallback(
-    (nodePath: string, level: PermissionLevel, updates: Partial<PermissionTarget>) => {
-      setLocalPermissions((prev) => {
-        const newPermissions = [...prev]
-
-        // Find the tree node to determine correct path pattern
-        const treeNode = findTreeNode(annotatedTree, nodePath)
-        const rawPath = treeNode?.type === 'folder' ? `${nodePath}/**` : nodePath
-        const parsed = parsePermissionPath(rawPath)
-        if (!parsed.ok) {
-          console.warn(`Invalid permission path skipped: ${rawPath} — ${parsed.error}`)
-          return prev
-        }
-        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: PermissionTarget = {
-            ...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 }
-          } else {
-            newPermissions[existingIndex] = {
-              ...existing,
-              [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,
-              [level]: updates,
-            })
-          }
-        }
-
-        return newPermissions
-      })
-      setIsDirty(true)
-    },
-    [annotatedTree],
-  )
-
-  const resetPermissions = useCallback(() => {
-    setLocalPermissions(permissions)
-    setIsDirty(false)
-    setSelectedNode(null)
-  }, [permissions])
-
-  return {
-    annotatedTree,
-    expandedNodes,
-    selectedNode,
-    localPermissions,
-    isDirty,
-    toggleNode,
-    expandAll,
-    collapseAll,
-    selectNode,
-    updateNodePermission,
-    resetPermissions,
-    setIsDirty,
-    setLocalPermissions,
-  }
-}