nebula-cms 0.1.0

package/tests/client/js/utils/slug.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest';
+import { slugify } from '../../../../src/client/js/utils/slug';
+
+describe('slugify', () => {
+  it('lowercases the input', () => {
+    expect(slugify('Hello World')).toBe('hello-world');
+  });
+
+  it('replaces spaces with hyphens', () => {
+    expect(slugify('foo bar baz')).toBe('foo-bar-baz');
+  });
+
+  it('replaces special characters with hyphens', () => {
+    expect(slugify('hello! world?')).toBe('hello-world');
+  });
+
+  it('collapses consecutive hyphens into one', () => {
+    expect(slugify('foo---bar')).toBe('foo-bar');
+  });
+
+  it('trims leading hyphens', () => {
+    expect(slugify('---foo')).toBe('foo');
+  });
+
+  it('trims trailing hyphens', () => {
+    expect(slugify('foo---')).toBe('foo');
+  });
+
+  it('handles unicode characters by replacing them with hyphens', () => {
+    expect(slugify('café')).toBe('caf');
+  });
+
+  it('handles strings with only special characters', () => {
+    expect(slugify('!@#$%')).toBe('');
+  });
+
+  it('returns an empty string for an empty input', () => {
+    expect(slugify('')).toBe('');
+  });
+
+  it('leaves an already-slugified string unchanged', () => {
+    expect(slugify('already-a-slug')).toBe('already-a-slug');
+  });
+
+  it('handles numeric characters', () => {
+    expect(slugify('Post 42')).toBe('post-42');
+  });
+
+  it('handles mixed alphanumeric and special characters', () => {
+    expect(slugify('My Post: The (2024) Edition!')).toBe(
+      'my-post-the-2024-edition',
+    );
+  });
+
+  it('preserves existing hyphens in the middle of words', () => {
+    expect(slugify('well-known')).toBe('well-known');
+  });
+});

package/tests/client/js/utils/sort.test.ts

@@ -0,0 +1,276 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import {
+  toSortDate,
+  createComparator,
+  readSortMode,
+  writeSortMode,
+  SORT_MODES,
+  SORT_ORDER,
+} from '../../../../src/client/js/utils/sort';
+import type { SidebarItem } from '../../../../src/client/js/utils/sort';
+
+//////////////////////////////
+// localStorage mock helpers
+//////////////////////////////
+
+/**
+ * Minimal in-memory localStorage mock. The unit test environment runs in Node
+ * which has no built-in localStorage, so we stub it globally for the tests
+ * that exercise readSortMode / writeSortMode.
+ */
+function makeLocalStorageMock(): Storage {
+  let store: Record<string, string> = {};
+  return {
+    getItem: (key: string) => store[key] ?? null,
+    setItem: (key: string, value: string) => {
+      store[key] = value;
+    },
+    removeItem: (key: string) => {
+      delete store[key];
+    },
+    clear: () => {
+      store = {};
+    },
+    get length() {
+      return Object.keys(store).length;
+    },
+    key: (index: number) => Object.keys(store)[index] ?? null,
+  } as Storage;
+}
+
+//////////////////////////////
+// toSortDate
+//////////////////////////////
+
+describe('toSortDate', () => {
+  it('returns a Date unchanged when passed a Date instance', () => {
+    const d = new Date('2024-01-15');
+    expect(toSortDate(d)).toBe(d);
+  });
+
+  it('parses a valid ISO date string into a Date', () => {
+    const result = toSortDate('2024-06-01');
+    expect(result).toBeInstanceOf(Date);
+    expect(result?.getFullYear()).toBe(2024);
+  });
+
+  it('parses a valid ISO datetime string into a Date', () => {
+    const result = toSortDate('2024-06-01T12:00:00Z');
+    expect(result).toBeInstanceOf(Date);
+  });
+
+  it('returns a Date (possibly Invalid) for a non-date string — callers handle invalid dates', () => {
+    // The function returns new Date(str) for any string; invalid date strings
+    // yield an Invalid Date object rather than undefined.
+    const result = toSortDate('not-a-date');
+    expect(result).toBeInstanceOf(Date);
+  });
+
+  it('returns undefined for null', () => {
+    expect(toSortDate(null)).toBeUndefined();
+  });
+
+  it('returns undefined for undefined', () => {
+    expect(toSortDate(undefined)).toBeUndefined();
+  });
+
+  it('returns undefined for a number', () => {
+    expect(toSortDate(42)).toBeUndefined();
+  });
+
+  it('returns undefined for an object', () => {
+    expect(toSortDate({ date: '2024-01-01' })).toBeUndefined();
+  });
+});
+
+//////////////////////////////
+// createComparator — alpha mode
+//////////////////////////////
+
+describe('createComparator — alpha', () => {
+  const cmp = createComparator('alpha');
+
+  it('sorts items lexicographically by label', () => {
+    const a: SidebarItem = { label: 'Banana', href: '/b' };
+    const b: SidebarItem = { label: 'Apple', href: '/a' };
+    expect(cmp(a, b)).toBeGreaterThan(0);
+    expect(cmp(b, a)).toBeLessThan(0);
+  });
+
+  it('returns 0 for identical labels', () => {
+    const a: SidebarItem = { label: 'Same', href: '/a' };
+    const b: SidebarItem = { label: 'Same', href: '/b' };
+    expect(cmp(a, b)).toBe(0);
+  });
+
+  it('is case-insensitive', () => {
+    const a: SidebarItem = { label: 'apple', href: '/a' };
+    const b: SidebarItem = { label: 'Apple', href: '/b' };
+    expect(cmp(a, b)).toBe(0);
+  });
+});
+
+//////////////////////////////
+// createComparator — date-asc mode
+//////////////////////////////
+
+describe('createComparator — date-asc', () => {
+  const cmp = createComparator('date-asc');
+
+  it('sorts earlier dates before later dates', () => {
+    const a: SidebarItem = {
+      label: 'A',
+      href: '/a',
+      date: new Date('2023-01-01'),
+    };
+    const b: SidebarItem = {
+      label: 'B',
+      href: '/b',
+      date: new Date('2024-01-01'),
+    };
+    expect(cmp(a, b)).toBeLessThan(0);
+    expect(cmp(b, a)).toBeGreaterThan(0);
+  });
+
+  it('returns 0 for equal dates', () => {
+    const a: SidebarItem = {
+      label: 'A',
+      href: '/a',
+      date: new Date('2024-01-01'),
+    };
+    const b: SidebarItem = {
+      label: 'B',
+      href: '/b',
+      date: new Date('2024-01-01'),
+    };
+    expect(cmp(a, b)).toBe(0);
+  });
+
+  it('sorts items without a date to the top (before items with a date)', () => {
+    const nodateItem: SidebarItem = { label: 'A', href: '/a' };
+    const datedItem: SidebarItem = {
+      label: 'B',
+      href: '/b',
+      date: new Date('2020-01-01'),
+    };
+    expect(cmp(nodateItem, datedItem)).toBeLessThan(0);
+    expect(cmp(datedItem, nodateItem)).toBeGreaterThan(0);
+  });
+
+  it('returns 0 when both items have no date', () => {
+    const a: SidebarItem = { label: 'A', href: '/a' };
+    const b: SidebarItem = { label: 'B', href: '/b' };
+    expect(cmp(a, b)).toBe(0);
+  });
+});
+
+//////////////////////////////
+// createComparator — date-desc mode
+//////////////////////////////
+
+describe('createComparator — date-desc', () => {
+  const cmp = createComparator('date-desc');
+
+  it('sorts later dates before earlier dates', () => {
+    const a: SidebarItem = {
+      label: 'A',
+      href: '/a',
+      date: new Date('2024-01-01'),
+    };
+    const b: SidebarItem = {
+      label: 'B',
+      href: '/b',
+      date: new Date('2023-01-01'),
+    };
+    expect(cmp(a, b)).toBeLessThan(0);
+    expect(cmp(b, a)).toBeGreaterThan(0);
+  });
+
+  it('sorts items without a date to the top', () => {
+    const nodateItem: SidebarItem = { label: 'A', href: '/a' };
+    const datedItem: SidebarItem = {
+      label: 'B',
+      href: '/b',
+      date: new Date('2020-01-01'),
+    };
+    expect(cmp(nodateItem, datedItem)).toBeLessThan(0);
+  });
+});
+
+//////////////////////////////
+// readSortMode / writeSortMode
+//////////////////////////////
+
+describe('readSortMode / writeSortMode', () => {
+  beforeEach(() => {
+    // Stub localStorage globally — Node has no built-in localStorage
+    vi.stubGlobal('localStorage', makeLocalStorageMock());
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('defaults to "alpha" when no value is stored', () => {
+    expect(readSortMode('my-collection')).toBe('alpha');
+  });
+
+  it('returns the stored "alpha" mode', () => {
+    writeSortMode('my-collection', 'alpha');
+    expect(readSortMode('my-collection')).toBe('alpha');
+  });
+
+  it('returns the stored "date-asc" mode', () => {
+    writeSortMode('my-collection', 'date-asc');
+    expect(readSortMode('my-collection')).toBe('date-asc');
+  });
+
+  it('returns the stored "date-desc" mode', () => {
+    writeSortMode('my-collection', 'date-desc');
+    expect(readSortMode('my-collection')).toBe('date-desc');
+  });
+
+  it('defaults to "alpha" when the stored value is not a valid SortMode', () => {
+    localStorage.setItem('cms-sort-my-collection', 'invalid-value');
+    expect(readSortMode('my-collection')).toBe('alpha');
+  });
+
+  it('namespaces storage keys by collection name', () => {
+    writeSortMode('posts', 'date-desc');
+    writeSortMode('pages', 'date-asc');
+    expect(readSortMode('posts')).toBe('date-desc');
+    expect(readSortMode('pages')).toBe('date-asc');
+  });
+});
+
+//////////////////////////////
+// SORT_MODES and SORT_ORDER constants
+//////////////////////////////
+
+describe('SORT_MODES constant', () => {
+  it('contains an entry for every SortMode', () => {
+    expect(SORT_MODES).toHaveProperty('alpha');
+    expect(SORT_MODES).toHaveProperty('date-asc');
+    expect(SORT_MODES).toHaveProperty('date-desc');
+  });
+
+  it('each entry has icon and label strings', () => {
+    for (const entry of Object.values(SORT_MODES)) {
+      expect(typeof entry.icon).toBe('string');
+      expect(typeof entry.label).toBe('string');
+    }
+  });
+});
+
+describe('SORT_ORDER constant', () => {
+  it('is an array with exactly 3 entries', () => {
+    expect(Array.isArray(SORT_ORDER)).toBe(true);
+    expect(SORT_ORDER).toHaveLength(3);
+  });
+
+  it('contains all three SortMode values', () => {
+    expect(SORT_ORDER).toContain('alpha');
+    expect(SORT_ORDER).toContain('date-asc');
+    expect(SORT_ORDER).toContain('date-desc');
+  });
+});

package/tests/client/js/utils/stable-stringify.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect } from 'vitest';
+import { stableStringify } from '../../../../src/client/js/utils/stable-stringify';
+
+describe('stableStringify', () => {
+  it('produces the same output regardless of key insertion order', () => {
+    const objA = { z: 1, a: 2, m: 3 };
+    const objB = { a: 2, m: 3, z: 1 };
+    expect(stableStringify(objA)).toBe(stableStringify(objB));
+  });
+
+  it('sorts keys alphabetically at the top level', () => {
+    const obj = { z: 1, a: 2, m: 3 };
+    expect(stableStringify(obj)).toBe('{"a":2,"m":3,"z":1}');
+  });
+
+  it('sorts keys recursively in nested objects', () => {
+    const obj = { b: { y: 1, x: 2 }, a: { q: 3, p: 4 } };
+    expect(stableStringify(obj)).toBe('{"a":{"p":4,"q":3},"b":{"x":2,"y":1}}');
+  });
+
+  it('preserves array element order (arrays are not sorted)', () => {
+    const obj = { items: [3, 1, 2] };
+    expect(stableStringify(obj)).toBe('{"items":[3,1,2]}');
+  });
+
+  it('handles null values correctly', () => {
+    const obj = { a: null, b: 'text' };
+    expect(stableStringify(obj)).toBe('{"a":null,"b":"text"}');
+  });
+
+  it('handles a top-level null', () => {
+    expect(stableStringify(null)).toBe('null');
+  });
+
+  it('serializes an empty object', () => {
+    expect(stableStringify({})).toBe('{}');
+  });
+
+  it('serializes an empty array', () => {
+    expect(stableStringify([])).toBe('[]');
+  });
+
+  it('serializes primitive string values', () => {
+    expect(stableStringify('hello')).toBe('"hello"');
+  });
+
+  it('serializes primitive number values', () => {
+    expect(stableStringify(42)).toBe('42');
+  });
+
+  it('serializes boolean values', () => {
+    expect(stableStringify(true)).toBe('true');
+    expect(stableStringify(false)).toBe('false');
+  });
+
+  it('handles arrays containing objects with sorted keys', () => {
+    const arr = [
+      { b: 2, a: 1 },
+      { d: 4, c: 3 },
+    ];
+    expect(stableStringify(arr)).toBe('[{"a":1,"b":2},{"c":3,"d":4}]');
+  });
+
+  it('is deterministic across multiple calls', () => {
+    const obj = { x: { q: 1, p: 2 }, a: [3, 2, 1] };
+    expect(stableStringify(obj)).toBe(stableStringify(obj));
+  });
+});

package/tests/client/js/utils/url-utils.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect } from 'vitest';
+import { isURL } from '../../../../src/client/js/utils/url-utils';
+
+describe('isURL', () => {
+  // Valid absolute URLs
+  it('returns true for an https URL', () => {
+    expect(isURL('https://example.com')).toBe(true);
+  });
+
+  it('returns true for an http URL', () => {
+    expect(isURL('http://example.com')).toBe(true);
+  });
+
+  it('returns true for an https URL with a path', () => {
+    expect(isURL('https://example.com/some/path')).toBe(true);
+  });
+
+  it('returns true for an https URL with query params', () => {
+    expect(isURL('https://example.com/search?q=test&page=2')).toBe(true);
+  });
+
+  it('returns true for a mailto: URL', () => {
+    expect(isURL('mailto:user@example.com')).toBe(true);
+  });
+
+  // Absolute paths
+  it('returns true for an absolute path starting with /', () => {
+    expect(isURL('/some/path')).toBe(true);
+  });
+
+  it('returns true for the root path /', () => {
+    expect(isURL('/')).toBe(true);
+  });
+
+  // Non-URLs
+  it('returns false for plain text', () => {
+    expect(isURL('hello world')).toBe(false);
+  });
+
+  it('returns false for a relative path without leading slash', () => {
+    expect(isURL('some/relative/path')).toBe(false);
+  });
+
+  it('returns false for a word that looks like a domain but has no scheme', () => {
+    expect(isURL('example.com')).toBe(false);
+  });
+
+  it('returns true for a protocol-relative URL — it starts with / so the absolute-path branch accepts it', () => {
+    // //example.com/path starts with /, so new URL('//example.com/path', 'https://a.com')
+    // resolves successfully. The function accepts absolute paths without requiring a scheme.
+    expect(isURL('//example.com/path')).toBe(true);
+  });
+
+  // Edge cases
+  it('returns false for an empty string', () => {
+    expect(isURL('')).toBe(false);
+  });
+
+  it('returns false for a whitespace-only string', () => {
+    expect(isURL('   ')).toBe(false);
+  });
+
+  it('trims whitespace before validation — valid URL with surrounding spaces', () => {
+    expect(isURL('  https://example.com  ')).toBe(true);
+  });
+
+  it('trims whitespace before validation — plain text with surrounding spaces', () => {
+    expect(isURL('  hello  ')).toBe(false);
+  });
+});