nebula-cms 0.1.3 → 0.1.4

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

@@ -1,58 +0,0 @@
-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

@@ -1,276 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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);
-  });
-});