canopycms 0.0.0 → 0.0.2

package/src/editor/editor-config.test.ts

@@ -1,385 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { flattenSchema } from '../config'
-import { buildEditorCollections, buildPreviewBaseByCollection } from './editor-config'
-
-const baseConfig = {
-  contentRoot: 'content',
-  schema: {
-    collections: [
-      {
-        name: 'posts',
-        label: 'Posts',
-        path: 'posts',
-        entries: [
-          {
-            name: 'entry',
-            format: 'json' as const,
-            schema: [],
-          },
-        ],
-      },
-      {
-        name: 'nested',
-        path: 'nested',
-        entries: [
-          {
-            name: 'entry',
-            format: 'md' as const,
-            schema: [],
-          },
-        ],
-        collections: [
-          {
-            name: 'child',
-            path: 'child',
-            entries: [
-              {
-                name: 'entry',
-                format: 'md' as const,
-                schema: [],
-              },
-            ],
-          },
-        ],
-      },
-    ],
-  },
-}
-
-describe('editor-config helpers', () => {
-  it('builds editor collections from schema/config', () => {
-    const collections = buildEditorCollections(
-      flattenSchema(baseConfig.schema, baseConfig.contentRoot),
-    )
-
-    // With schema refactor, content root is now a visible collection
-    expect(collections).toHaveLength(1)
-    expect(collections[0].path).toBe('content')
-    expect(collections[0].children).toHaveLength(2)
-    expect(collections[0].children!.map((c) => c.path).sort()).toEqual([
-      'content/nested',
-      'content/posts',
-    ])
-
-    // Verify nested collection structure
-    const nested = collections[0].children!.find((c) => c.path === 'content/nested')
-    expect(nested?.type).toBe('collection')
-    expect(nested?.children?.[0]?.path).toBe('content/nested/child')
-
-    // Verify posts collection
-    const posts = collections[0].children!.find((c) => c.path === 'content/posts')
-    expect(posts?.type).toBe('collection')
-    expect(posts?.format).toBe('json')
-  })
-
-  it('derives preview bases from content root and schema paths', () => {
-    const previewBase = buildPreviewBaseByCollection(
-      baseConfig,
-      flattenSchema(baseConfig.schema, baseConfig.contentRoot),
-    )
-    expect(previewBase['content/posts']).toBe('/posts')
-    expect(previewBase['content/nested']).toBe('/nested')
-    expect(previewBase['content/nested/child']).toBe('/nested/child')
-  })
-
-  it('trims content root slashes when building preview bases', () => {
-    const config = {
-      ...baseConfig,
-      contentRoot: '/site/content/',
-    }
-    const previewBase = buildPreviewBaseByCollection(
-      config,
-      flattenSchema(config.schema, config.contentRoot),
-    )
-    expect(previewBase['site/content/posts']).toBe('/posts')
-  })
-
-  it('includes nested collections under parent collections', () => {
-    const config = {
-      contentRoot: 'content',
-      schema: {
-        collections: [
-          {
-            name: 'docs',
-            path: 'docs',
-            entries: [
-              {
-                name: 'entry',
-                format: 'mdx' as const,
-                schema: [],
-              },
-            ],
-            collections: [
-              {
-                name: 'api',
-                path: 'api',
-                entries: [
-                  {
-                    name: 'doc',
-                    format: 'md' as const,
-                    schema: [],
-                  },
-                ],
-              },
-            ],
-          },
-        ],
-      },
-    }
-
-    const collections = buildEditorCollections(flattenSchema(config.schema, config.contentRoot))
-
-    // Content root is the top-level collection
-    expect(collections).toHaveLength(1)
-    expect(collections[0].path).toBe('content')
-    expect(collections[0].children).toHaveLength(1)
-
-    // Docs is a child of content
-    const docs = collections[0].children![0]
-    expect(docs.path).toBe('content/docs')
-    expect(docs.type).toBe('collection')
-    expect(docs.children).toHaveLength(1)
-
-    // API is nested under docs
-    const api = docs.children?.[0]
-    expect(api?.path).toBe('content/docs/api')
-    expect(api?.name).toBe('api')
-    expect(api?.type).toBe('collection')
-    expect(api?.format).toBe('md')
-  })
-
-  it.skip('includes root-level entry types with maxItems: 1 as navigable entries', () => {
-    const config = {
-      contentRoot: 'content',
-      schema: {
-        entries: [
-          {
-            name: 'home',
-            label: 'Home',
-            format: 'json' as const,
-            schema: [],
-            maxItems: 1,
-          },
-          {
-            name: 'settings',
-            label: 'Settings',
-            format: 'json' as const,
-            schema: [],
-            maxItems: 1,
-          },
-        ],
-        collections: [
-          {
-            name: 'posts',
-            path: 'posts',
-            entries: [
-              {
-                name: 'post',
-                format: 'mdx' as const,
-                schema: [],
-              },
-            ],
-          },
-        ],
-      },
-    }
-
-    const collections = buildEditorCollections(flattenSchema(config.schema, config.contentRoot))
-
-    // Content root is the top-level collection
-    expect(collections).toHaveLength(1)
-    expect(collections[0].path).toBe('content')
-
-    // Children should have 3 items: 2 root-level entries + 1 collection
-    const children = collections[0].children!
-    expect(children).toHaveLength(3)
-
-    // Root-level entries with maxItems: 1 should appear as type 'entry'
-    const home = children.find((c) => c.path === 'content/home')
-    expect(home).toBeDefined()
-    expect(home?.type).toBe('entry')
-    expect(home?.label).toBe('Home')
-    expect(home?.format).toBe('json')
-
-    const settings = children.find((c) => c.path === 'content/settings')
-    expect(settings).toBeDefined()
-    expect(settings?.type).toBe('entry')
-    expect(settings?.label).toBe('Settings')
-
-    // Collection should also be present as a child
-    const posts = children.find((c) => c.path === 'content/posts')
-    expect(posts).toBeDefined()
-    expect(posts?.type).toBe('collection')
-  })
-
-  it('excludes root-level entry types without maxItems: 1', () => {
-    const config = {
-      contentRoot: 'content',
-      schema: {
-        entries: [
-          {
-            name: 'page',
-            label: 'Page',
-            format: 'json' as const,
-            schema: [],
-            // No maxItems - should not be navigable
-          },
-        ],
-        collections: [
-          {
-            name: 'posts',
-            path: 'posts',
-            entries: [
-              {
-                name: 'post',
-                format: 'mdx' as const,
-                schema: [],
-              },
-            ],
-          },
-        ],
-      },
-    }
-
-    const collections = buildEditorCollections(flattenSchema(config.schema, config.contentRoot))
-
-    // The content root collection should be present with posts as a child
-    // Entry types without maxItems: 1 are not navigable
-    expect(collections).toHaveLength(1)
-    expect(collections[0].path).toBe('content')
-    expect(collections[0].children).toHaveLength(1)
-    expect(collections[0].children![0].path).toBe('content/posts')
-  })
-
-  it('excludes collection entry types from navigation', () => {
-    const config = {
-      contentRoot: 'content',
-      schema: {
-        collections: [
-          {
-            name: 'posts',
-            path: 'posts',
-            entries: [
-              {
-                name: 'post',
-                format: 'mdx' as const,
-                schema: [],
-              },
-              {
-                name: 'doc',
-                format: 'md' as const,
-                schema: [],
-              },
-            ],
-          },
-        ],
-      },
-    }
-
-    const collections = buildEditorCollections(flattenSchema(config.schema, config.contentRoot))
-
-    // The content root collection should be present with posts as a child
-    expect(collections).toHaveLength(1)
-    expect(collections[0].path).toBe('content')
-    expect(collections[0].type).toBe('collection')
-    expect(collections[0].children).toHaveLength(1)
-
-    // The posts collection should be present, not its entry types
-    const posts = collections[0].children![0]
-    expect(posts.path).toBe('content/posts')
-    expect(posts.type).toBe('collection')
-    // Entry types within a collection are not children in the navigation
-    expect(posts.children).toHaveLength(0)
-  })
-
-  it('populates entryTypes from flatSchema collection entries', () => {
-    const config = {
-      contentRoot: 'content',
-      schema: {
-        collections: [
-          {
-            name: 'posts',
-            path: 'posts',
-            entries: [
-              {
-                name: 'post',
-                format: 'mdx' as const,
-                schema: [],
-                default: true,
-                label: 'Blog Post',
-              },
-              {
-                name: 'draft',
-                format: 'mdx' as const,
-                schema: [],
-                label: 'Draft',
-                maxItems: 10,
-              },
-            ],
-          },
-        ],
-      },
-    }
-
-    const collections = buildEditorCollections(flattenSchema(config.schema, config.contentRoot))
-
-    const posts = collections[0].children![0]
-    expect(posts.entryTypes).toHaveLength(2)
-    expect(posts.entryTypes![0]).toEqual({
-      name: 'post',
-      format: 'mdx',
-      default: true,
-      label: 'Blog Post',
-      maxItems: undefined,
-    })
-    expect(posts.entryTypes![1]).toEqual({
-      name: 'draft',
-      format: 'mdx',
-      label: 'Draft',
-      default: undefined,
-      maxItems: 10,
-    })
-  })
-
-  it('populates order from flatSchema collection', () => {
-    const config = {
-      contentRoot: 'content',
-      schema: {
-        collections: [
-          {
-            name: 'posts',
-            path: 'posts',
-            entries: [{ name: 'post', format: 'json' as const, schema: [] }],
-            order: ['abc123', 'def456'],
-          },
-        ],
-      },
-    }
-
-    const collections = buildEditorCollections(flattenSchema(config.schema, config.contentRoot))
-
-    const posts = collections[0].children![0]
-    expect(posts.order).toEqual(['abc123', 'def456'])
-  })
-
-  it('omits entryTypes when collection has no entries', () => {
-    const config = {
-      contentRoot: 'content',
-      schema: {
-        collections: [
-          {
-            name: 'empty',
-            path: 'empty',
-            entries: [],
-          },
-        ],
-      },
-    }
-
-    const collections = buildEditorCollections(flattenSchema(config.schema, config.contentRoot))
-
-    const empty = collections[0].children![0]
-    expect(empty.entryTypes).toBeUndefined()
-  })
-})

package/src/editor/editor-config.ts

@@ -1,94 +0,0 @@
-import type { CanopyConfig, FlatSchemaItem } from '../config'
-import type { EditorCollection, EditorEntryType } from './Editor'
-
-const normalizeContentRoot = (value?: string): string => {
-  const trimmed = (value ?? 'content').replace(/^\/+|\/+$/g, '')
-  return trimmed
-}
-
-const stripContentRoot = (logicalPath: string, contentRoot: string): string => {
-  const prefix = contentRoot ? `${contentRoot}/` : ''
-  if (prefix && logicalPath.startsWith(prefix)) {
-    return logicalPath.slice(prefix.length)
-  }
-  return logicalPath
-}
-
-/**
- * Build hierarchical editor collections from the flattened schema.
- * Uses logicalPath as IDs to match API responses.
- * Optimized to O(n) using Map-based grouping.
- *
- * Only collections are returned - entry types are schema metadata, not navigable nodes.
- * Entry types define the schema for entries within a collection but are not themselves
- * shown as separate nodes in the navigation tree.
- */
-export const buildEditorCollections = (flatSchema: FlatSchemaItem[]): EditorCollection[] => {
-  const flat = flatSchema
-
-  // Group items by parentPath for O(1) lookup - O(n) total
-  const childrenByParent = new Map<string | undefined, FlatSchemaItem[]>()
-  for (const item of flat) {
-    const key = item.parentPath
-    if (!childrenByParent.has(key)) {
-      childrenByParent.set(key, [])
-    }
-    childrenByParent.get(key)!.push(item)
-  }
-
-  // Build tree recursively using the grouped map
-  const buildTree = (parentPath?: string): EditorCollection[] => {
-    const children = childrenByParent.get(parentPath) || []
-    const results: EditorCollection[] = []
-
-    for (const item of children) {
-      if (item.type === 'collection') {
-        // Collections are always navigable
-        const defaultEntry = item.entries?.find((e) => e.default) || item.entries?.[0]
-        const entryTypes: EditorEntryType[] | undefined = item.entries?.map((et) => ({
-          name: et.name,
-          label: et.label,
-          format: et.format,
-          default: et.default,
-          maxItems: et.maxItems,
-        }))
-        results.push({
-          path: item.logicalPath,
-          contentId: item.contentId,
-          name: item.name,
-          label: item.label,
-          format: defaultEntry?.format || 'json',
-          type: 'collection' as const,
-          entryTypes: entryTypes && entryTypes.length > 0 ? entryTypes : undefined,
-          order: item.order,
-          children: buildTree(item.logicalPath), // Recursively build children
-        })
-      }
-      // Entry types are NOT included - they're schema metadata, not navigable nodes
-    }
-
-    return results
-  }
-
-  // Start with root-level collections (parentPath: undefined)
-  // This now includes the content root collection itself
-  return buildTree(undefined)
-}
-
-export const buildPreviewBaseByCollection = (
-  config: Pick<CanopyConfig, 'contentRoot'>,
-  flatSchema: FlatSchemaItem[],
-): Record<string, string> => {
-  const contentRoot = normalizeContentRoot(config.contentRoot)
-  const flat = flatSchema
-  const map: Record<string, string> = {}
-
-  for (const item of flat) {
-    // Strip content root from all items and normalize to preview URL
-    const base = stripContentRoot(item.logicalPath, contentRoot)
-    const normalizedBase = base ? `/${base}` : '/'
-    map[item.logicalPath] = normalizedBase
-  }
-
-  return map
-}