@actuate-media/cms-admin 0.8.0 → 0.8.2

package/src/__tests__/lib/search.test.ts

@@ -1,38 +1,33 @@
-import { describe, it, expect } from 'vitest';
-import {
-  scoreRelevance,
-  sortByRelevance,
-  sortByColumn,
-  toggleSort,
-} from '../../lib/search.js';
+import { describe, it, expect } from 'vitest'
+import { scoreRelevance, sortByRelevance, sortByColumn, toggleSort } from '../../lib/search.js'
 
 describe('scoreRelevance', () => {
   it('returns 100 for exact match (case-insensitive)', () => {
-    expect(scoreRelevance('Hello', 'hello')).toBe(100);
-    expect(scoreRelevance('test', 'test')).toBe(100);
-  });
+    expect(scoreRelevance('Hello', 'hello')).toBe(100)
+    expect(scoreRelevance('test', 'test')).toBe(100)
+  })
 
   it('returns 80 when text starts with the query', () => {
-    expect(scoreRelevance('hello world', 'hel')).toBe(80);
-    expect(scoreRelevance('Alpha', 'al')).toBe(80);
-  });
+    expect(scoreRelevance('hello world', 'hel')).toBe(80)
+    expect(scoreRelevance('Alpha', 'al')).toBe(80)
+  })
 
   it('returns 60 when query matches at a word boundary but not at start', () => {
-    expect(scoreRelevance('say hello', 'hello')).toBe(60);
-  });
+    expect(scoreRelevance('say hello', 'hello')).toBe(60)
+  })
 
   it('returns 40 when query appears only as a substring without word-boundary match', () => {
-    expect(scoreRelevance('axxhello', 'hello')).toBe(40);
-  });
+    expect(scoreRelevance('axxhello', 'hello')).toBe(40)
+  })
 
   it('returns 0 when there is no match', () => {
-    expect(scoreRelevance('abc def', 'xyz')).toBe(0);
-  });
+    expect(scoreRelevance('abc def', 'xyz')).toBe(0)
+  })
 
   it('returns 0 for an empty query', () => {
-    expect(scoreRelevance('anything', '')).toBe(0);
-  });
-});
+    expect(scoreRelevance('anything', '')).toBe(0)
+  })
+})
 
 describe('sortByRelevance', () => {
   it('sorts items by best field relevance score descending', () => {
@@ -40,99 +35,95 @@ describe('sortByRelevance', () => {
       { id: 'a', title: 'zzz' },
       { id: 'b', title: 'hello' },
       { id: 'c', title: 'say hello' },
-    ];
-    const sorted = sortByRelevance(items, 'hello', item => [item.title]);
+    ]
+    const sorted = sortByRelevance(items, 'hello', (item) => [item.title])
     // exact match > word-boundary match > no match
-    expect(sorted.map(i => i.id)).toEqual(['b', 'c', 'a']);
-  });
+    expect(sorted.map((i) => i.id)).toEqual(['b', 'c', 'a'])
+  })
 
   it('returns the original array reference for an empty query', () => {
-    const items = [{ id: '1' }, { id: '2' }];
-    const result = sortByRelevance(items, '', item => [item.id]);
-    expect(result).toBe(items);
-  });
+    const items = [{ id: '1' }, { id: '2' }]
+    const result = sortByRelevance(items, '', (item) => [item.id])
+    expect(result).toBe(items)
+  })
 
   it('returns the original array when query is whitespace-only', () => {
-    const items = [{ id: '1' }];
-    expect(sortByRelevance(items, '   ', item => [item.id])).toBe(items);
-  });
+    const items = [{ id: '1' }]
+    expect(sortByRelevance(items, '   ', (item) => [item.id])).toBe(items)
+  })
 
   it('uses the maximum score across multiple search fields', () => {
     const items = [
       { id: 'low', a: 'x', b: 'x' },
       { id: 'high', a: 'x', b: 'exact' },
-    ];
-    const sorted = sortByRelevance(items, 'exact', item => [item.a, item.b]);
-    expect(sorted[0]!.id).toBe('high');
-  });
-});
+    ]
+    const sorted = sortByRelevance(items, 'exact', (item) => [item.a, item.b])
+    expect(sorted[0]!.id).toBe('high')
+  })
+})
 
 describe('sortByColumn', () => {
   it('returns the original array when sortConfig is null', () => {
-    const items = [{ n: 2 }, { n: 1 }];
-    expect(sortByColumn(items, null, (item, key) => item[key as 'n'])).toBe(items);
-  });
+    const items = [{ n: 2 }, { n: 1 }]
+    expect(sortByColumn(items, null, (item, key) => item[key as 'n'])).toBe(items)
+  })
 
   it('sorts strings ascending', () => {
-    const items = [{ name: 'b' }, { name: 'a' }, { name: 'c' }];
+    const items = [{ name: 'b' }, { name: 'a' }, { name: 'c' }]
     const sorted = sortByColumn(
       items,
       { key: 'name', direction: 'asc' },
       (item, key) => item[key as 'name'],
-    );
-    expect(sorted.map(i => i.name)).toEqual(['a', 'b', 'c']);
-  });
+    )
+    expect(sorted.map((i) => i.name)).toEqual(['a', 'b', 'c'])
+  })
 
   it('sorts strings descending', () => {
-    const items = [{ name: 'a' }, { name: 'c' }, { name: 'b' }];
+    const items = [{ name: 'a' }, { name: 'c' }, { name: 'b' }]
     const sorted = sortByColumn(
       items,
       { key: 'name', direction: 'desc' },
       (item, key) => item[key as 'name'],
-    );
-    expect(sorted.map(i => i.name)).toEqual(['c', 'b', 'a']);
-  });
+    )
+    expect(sorted.map((i) => i.name)).toEqual(['c', 'b', 'a'])
+  })
 
   it('sorts numbers ascending and descending', () => {
-    const items = [{ v: 3 }, { v: 1 }, { v: 2 }];
-    const asc = sortByColumn(
-      items,
-      { key: 'v', direction: 'asc' },
-      (item, key) => item[key as 'v'],
-    );
-    expect(asc.map(i => i.v)).toEqual([1, 2, 3]);
+    const items = [{ v: 3 }, { v: 1 }, { v: 2 }]
+    const asc = sortByColumn(items, { key: 'v', direction: 'asc' }, (item, key) => item[key as 'v'])
+    expect(asc.map((i) => i.v)).toEqual([1, 2, 3])
     const desc = sortByColumn(
       items,
       { key: 'v', direction: 'desc' },
       (item, key) => item[key as 'v'],
-    );
-    expect(desc.map(i => i.v)).toEqual([3, 2, 1]);
-  });
-});
+    )
+    expect(desc.map((i) => i.v)).toEqual([3, 2, 1])
+  })
+})
 
 describe('toggleSort', () => {
   it('returns ascending sort when current is null', () => {
-    expect(toggleSort(null, 'title')).toEqual({ key: 'title', direction: 'asc' });
-  });
+    expect(toggleSort(null, 'title')).toEqual({ key: 'title', direction: 'asc' })
+  })
 
   it('toggles same key from asc to desc', () => {
     expect(toggleSort({ key: 'title', direction: 'asc' }, 'title')).toEqual({
       key: 'title',
       direction: 'desc',
-    });
-  });
+    })
+  })
 
   it('toggles same key from desc to asc', () => {
     expect(toggleSort({ key: 'title', direction: 'desc' }, 'title')).toEqual({
       key: 'title',
       direction: 'asc',
-    });
-  });
+    })
+  })
 
   it('starts ascending when switching to a different key', () => {
     expect(toggleSort({ key: 'foo', direction: 'desc' }, 'bar')).toEqual({
       key: 'bar',
       direction: 'asc',
-    });
-  });
-});
+    })
+  })
+})

package/src/__tests__/lib/utils.test.ts

@@ -1,19 +1,19 @@
-import { describe, it, expect } from 'vitest';
-import { cn } from '../../lib/utils.js';
+import { describe, it, expect } from 'vitest'
+import { cn } from '../../lib/utils.js'
 
 describe('cn', () => {
   it('merges multiple class names into a single string', () => {
-    expect(cn('foo', 'bar')).toBe('foo bar');
-    expect(cn('a', 'b', 'c')).toBe('a b c');
-  });
+    expect(cn('foo', 'bar')).toBe('foo bar')
+    expect(cn('a', 'b', 'c')).toBe('a b c')
+  })
 
   it('omits falsy conditional classes', () => {
-    expect(cn('base', false && 'hidden', 'visible')).toBe('base visible');
-    expect(cn('x', undefined, null, 0, 'y')).toBe('x y');
-  });
+    expect(cn('base', false && 'hidden', 'visible')).toBe('base visible')
+    expect(cn('x', undefined, null, 0, 'y')).toBe('x y')
+  })
 
   it('resolves conflicting Tailwind utilities in favor of the last one', () => {
-    expect(cn('p-4', 'p-2')).toBe('p-2');
-    expect(cn('text-sm', 'text-lg')).toBe('text-lg');
-  });
-});
+    expect(cn('p-4', 'p-2')).toBe('p-2')
+    expect(cn('text-sm', 'text-lg')).toBe('text-lg')
+  })
+})

package/src/__tests__/router/match-route.test.ts

@@ -1,47 +1,45 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect } from 'vitest'
 
 function matchRoute(currentPath: string, pattern: string): Record<string, string> | null {
-  const patternParts = pattern.split('/').filter(Boolean);
-  const pathParts = currentPath.split('/').filter(Boolean);
-  if (pattern === '/' && pathParts.length === 0) return {};
-  if (patternParts.length !== pathParts.length) return null;
-  const params: Record<string, string> = {};
+  const patternParts = pattern.split('/').filter(Boolean)
+  const pathParts = currentPath.split('/').filter(Boolean)
+  if (pattern === '/' && pathParts.length === 0) return {}
+  if (patternParts.length !== pathParts.length) return null
+  const params: Record<string, string> = {}
   for (let i = 0; i < patternParts.length; i++) {
-    const patternPart = patternParts[i]!;
-    const pathPart = pathParts[i]!;
+    const patternPart = patternParts[i]!
+    const pathPart = pathParts[i]!
     if (patternPart.startsWith(':')) {
-      params[patternPart.slice(1)] = pathPart;
+      params[patternPart.slice(1)] = pathPart
     } else if (patternPart !== pathPart) {
-      return null;
+      return null
     }
   }
-  return params;
+  return params
 }
 
 describe('matchRoute', () => {
   it('matches the root pattern against an empty path', () => {
-    expect(matchRoute('/', '/')).toEqual({});
-  });
+    expect(matchRoute('/', '/')).toEqual({})
+  })
 
   it('matches static multi-segment paths', () => {
-    expect(matchRoute('/collections/posts', '/collections/posts')).toEqual({});
-  });
+    expect(matchRoute('/collections/posts', '/collections/posts')).toEqual({})
+  })
 
   it('extracts named parameters from dynamic segments', () => {
     expect(matchRoute('/collections/posts/abc-123', '/collections/posts/:id')).toEqual({
       id: 'abc-123',
-    });
-    expect(
-      matchRoute('/users/u1/settings', '/users/:userId/settings'),
-    ).toEqual({ userId: 'u1' });
-  });
+    })
+    expect(matchRoute('/users/u1/settings', '/users/:userId/settings')).toEqual({ userId: 'u1' })
+  })
 
   it('returns null when a static segment does not match', () => {
-    expect(matchRoute('/collections/pages', '/collections/posts')).toBeNull();
-  });
+    expect(matchRoute('/collections/pages', '/collections/posts')).toBeNull()
+  })
 
   it('returns null when segment counts differ', () => {
-    expect(matchRoute('/a', '/a/b')).toBeNull();
-    expect(matchRoute('/a/b', '/a')).toBeNull();
-  });
-});
+    expect(matchRoute('/a', '/a/b')).toBeNull()
+    expect(matchRoute('/a/b', '/a')).toBeNull()
+  })
+})

package/src/__tests__/router/strip-base.test.ts

@@ -1,30 +1,30 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect } from 'vitest'
 
 // Copy of the internal stripBase function for testing
 function stripBase(pathname: string, basePath: string): string {
   if (pathname.startsWith(basePath)) {
-    const rest = pathname.slice(basePath.length);
-    return rest === '' || rest === '/' ? '/' : rest.startsWith('/') ? rest : `/${rest}`;
+    const rest = pathname.slice(basePath.length)
+    return rest === '' || rest === '/' ? '/' : rest.startsWith('/') ? rest : `/${rest}`
   }
-  return '/';
+  return '/'
 }
 
 describe('stripBase', () => {
   it('strips the base path and returns the remainder with a leading slash', () => {
-    expect(stripBase('/admin/dashboard', '/admin')).toBe('/dashboard');
-    expect(stripBase('/admin/collections/posts', '/admin')).toBe('/collections/posts');
-  });
+    expect(stripBase('/admin/dashboard', '/admin')).toBe('/dashboard')
+    expect(stripBase('/admin/collections/posts', '/admin')).toBe('/collections/posts')
+  })
 
   it('returns root when the pathname is exactly the base or base plus trailing slash', () => {
-    expect(stripBase('/admin', '/admin')).toBe('/');
-    expect(stripBase('/admin/', '/admin')).toBe('/');
-  });
+    expect(stripBase('/admin', '/admin')).toBe('/')
+    expect(stripBase('/admin/', '/admin')).toBe('/')
+  })
 
   it('returns root when the pathname does not start with the base path', () => {
-    expect(stripBase('/public/page', '/admin')).toBe('/');
-  });
+    expect(stripBase('/public/page', '/admin')).toBe('/')
+  })
 
   it('normalizes remainder that lacks a leading slash', () => {
-    expect(stripBase('/adminfoo', '/admin')).toBe('/foo');
-  });
-});
+    expect(stripBase('/adminfoo', '/admin')).toBe('/foo')
+  })
+})

package/src/components/Breadcrumbs.tsx

@@ -1,6 +1,6 @@
-'use client';
+'use client'
 
-import { ChevronRight, Home } from 'lucide-react';
+import { ChevronRight, Home } from 'lucide-react'
 
 const LABEL_MAP: Record<string, string> = {
   posts: 'Posts',
@@ -18,48 +18,51 @@ const LABEL_MAP: Record<string, string> = {
   submissions: 'Submissions',
   new: 'New',
   edit: 'Edit',
-};
+}
 
 function labelFor(segment: string): string {
-  return LABEL_MAP[segment] ?? segment.replace(/[-_]/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+  return (
+    LABEL_MAP[segment] ?? segment.replace(/[-_]/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase())
+  )
 }
 
 function isId(segment: string): boolean {
-  return /^\d+$/.test(segment) || /^[0-9a-f]{8,}$/i.test(segment);
+  return /^\d+$/.test(segment) || /^[0-9a-f]{8,}$/i.test(segment)
 }
 
 export interface BreadcrumbsProps {
-  currentPath: string;
-  onNavigate: (path: string) => void;
+  currentPath: string
+  onNavigate: (path: string) => void
 }
 
 export function Breadcrumbs({ currentPath, onNavigate }: BreadcrumbsProps) {
-  const segments = currentPath.split('/').filter(Boolean);
+  const segments = currentPath.split('/').filter(Boolean)
 
-  if (segments.length === 0) return null;
+  if (segments.length === 0) return null
 
-  const crumbs: { label: string; path: string }[] = [];
-  let accumulated = '';
+  const crumbs: { label: string; path: string }[] = []
+  let accumulated = ''
 
   for (let i = 0; i < segments.length; i++) {
-    const seg = segments[i]!;
-    accumulated += `/${seg}`;
+    const seg = segments[i]!
+    accumulated += `/${seg}`
 
-    let label: string;
+    let label: string
     if (isId(seg)) {
-      const parentLabel = i > 0 ? labelFor(segments[i - 1]!) : '';
-      label = parentLabel
-        ? `Edit ${parentLabel.replace(/s$/, '')}`
-        : `#${seg}`;
+      const parentLabel = i > 0 ? labelFor(segments[i - 1]!) : ''
+      label = parentLabel ? `Edit ${parentLabel.replace(/s$/, '')}` : `#${seg}`
     } else {
-      label = labelFor(seg);
+      label = labelFor(seg)
     }
 
-    crumbs.push({ label, path: accumulated });
+    crumbs.push({ label, path: accumulated })
   }
 
   return (
-    <nav aria-label="Breadcrumb" className="flex items-center gap-1 text-sm py-2.5 px-4 bg-white border-b border-gray-200 overflow-x-auto">
+    <nav
+      aria-label="Breadcrumb"
+      className="flex items-center gap-1 text-sm py-2.5 px-4 bg-white border-b border-gray-200 overflow-x-auto"
+    >
       <button
         type="button"
         onClick={() => onNavigate('/')}
@@ -70,7 +73,7 @@ export function Breadcrumbs({ currentPath, onNavigate }: BreadcrumbsProps) {
       </button>
 
       {crumbs.map((crumb, i) => {
-        const isLast = i === crumbs.length - 1;
+        const isLast = i === crumbs.length - 1
         return (
           <span key={crumb.path} className="flex items-center gap-1 shrink-0">
             <ChevronRight className="w-3.5 h-3.5 text-gray-400" />
@@ -86,8 +89,8 @@ export function Breadcrumbs({ currentPath, onNavigate }: BreadcrumbsProps) {
               </button>
             )}
           </span>
-        );
+        )
       })}
     </nav>
-  );
+  )
 }