nebula-cms 0.1.3 → 0.1.4

package/tests/client/js/utils/file-types.test.ts

@@ -1,268 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  getExtensionsForSchema,
-  hasBodyEditor,
-  getFileCategory,
-  getDataFormat,
-  stripExtension,
-  getDefaultExtension,
-} from '../../../../src/client/js/utils/file-types';
-
-//////////////////////////////
-// getExtensionsForSchema
-//////////////////////////////
-
-describe('getExtensionsForSchema', () => {
-  it('returns all extensions for a single type identifier', () => {
-    expect(getExtensionsForSchema({ files: ['md'] })).toEqual([
-      '.md',
-      '.markdown',
-    ]);
-  });
-
-  it('returns extensions for multiple type identifiers combined', () => {
-    expect(getExtensionsForSchema({ files: ['md', 'json'] })).toEqual([
-      '.md',
-      '.markdown',
-      '.json',
-    ]);
-  });
-
-  it('returns extensions for all frontmatter types', () => {
-    expect(getExtensionsForSchema({ files: ['md', 'mdx', 'markdoc'] })).toEqual(
-      ['.md', '.markdown', '.mdx', '.mdoc', '.markdoc'],
-    );
-  });
-
-  it('returns extensions for all data types', () => {
-    expect(getExtensionsForSchema({ files: ['json', 'yaml', 'toml'] })).toEqual(
-      ['.json', '.yml', '.yaml', '.toml'],
-    );
-  });
-
-  it('returns an empty array when files is empty', () => {
-    expect(getExtensionsForSchema({ files: [] })).toEqual([]);
-  });
-
-  it('skips unknown type identifiers without throwing', () => {
-    expect(getExtensionsForSchema({ files: ['md', 'unknown-type'] })).toEqual([
-      '.md',
-      '.markdown',
-    ]);
-  });
-
-  it('returns an empty array when files property is missing', () => {
-    expect(getExtensionsForSchema({})).toEqual([]);
-  });
-});
-
-//////////////////////////////
-// hasBodyEditor
-//////////////////////////////
-
-describe('hasBodyEditor', () => {
-  it('returns true for .md files', () => {
-    expect(hasBodyEditor('post.md')).toBe(true);
-  });
-
-  it('returns true for .markdown files', () => {
-    expect(hasBodyEditor('post.markdown')).toBe(true);
-  });
-
-  it('returns true for .mdx files', () => {
-    expect(hasBodyEditor('component.mdx')).toBe(true);
-  });
-
-  it('returns true for .mdoc files', () => {
-    expect(hasBodyEditor('doc.mdoc')).toBe(true);
-  });
-
-  it('returns true for .markdoc files', () => {
-    expect(hasBodyEditor('doc.markdoc')).toBe(true);
-  });
-
-  it('returns false for .json files', () => {
-    expect(hasBodyEditor('data.json')).toBe(false);
-  });
-
-  it('returns false for .yml files', () => {
-    expect(hasBodyEditor('config.yml')).toBe(false);
-  });
-
-  it('returns false for .yaml files', () => {
-    expect(hasBodyEditor('config.yaml')).toBe(false);
-  });
-
-  it('returns false for .toml files', () => {
-    expect(hasBodyEditor('config.toml')).toBe(false);
-  });
-
-  it('returns false for unrecognised extensions', () => {
-    expect(hasBodyEditor('file.txt')).toBe(false);
-  });
-});
-
-//////////////////////////////
-// getFileCategory
-//////////////////////////////
-
-describe('getFileCategory', () => {
-  it('returns frontmatter for .md files', () => {
-    expect(getFileCategory('post.md')).toBe('frontmatter');
-  });
-
-  it('returns frontmatter for .markdown files', () => {
-    expect(getFileCategory('post.markdown')).toBe('frontmatter');
-  });
-
-  it('returns frontmatter for .mdx files', () => {
-    expect(getFileCategory('component.mdx')).toBe('frontmatter');
-  });
-
-  it('returns frontmatter for .mdoc files', () => {
-    expect(getFileCategory('doc.mdoc')).toBe('frontmatter');
-  });
-
-  it('returns frontmatter for .markdoc files', () => {
-    expect(getFileCategory('doc.markdoc')).toBe('frontmatter');
-  });
-
-  it('returns data for .json files', () => {
-    expect(getFileCategory('data.json')).toBe('data');
-  });
-
-  it('returns data for .yml files', () => {
-    expect(getFileCategory('config.yml')).toBe('data');
-  });
-
-  it('returns data for .yaml files', () => {
-    expect(getFileCategory('config.yaml')).toBe('data');
-  });
-
-  it('returns data for .toml files', () => {
-    expect(getFileCategory('config.toml')).toBe('data');
-  });
-
-  it('returns null for unrecognised extensions', () => {
-    expect(getFileCategory('file.txt')).toBe(null);
-  });
-});
-
-//////////////////////////////
-// getDataFormat
-//////////////////////////////
-
-describe('getDataFormat', () => {
-  it('returns json for .json files', () => {
-    expect(getDataFormat('data.json')).toBe('json');
-  });
-
-  it('returns yaml for .yml files', () => {
-    expect(getDataFormat('config.yml')).toBe('yaml');
-  });
-
-  it('returns yaml for .yaml files', () => {
-    expect(getDataFormat('config.yaml')).toBe('yaml');
-  });
-
-  it('returns toml for .toml files', () => {
-    expect(getDataFormat('config.toml')).toBe('toml');
-  });
-
-  it('returns null for frontmatter files', () => {
-    expect(getDataFormat('post.md')).toBe(null);
-  });
-
-  it('returns null for .mdx files', () => {
-    expect(getDataFormat('component.mdx')).toBe(null);
-  });
-
-  it('returns null for unrecognised extensions', () => {
-    expect(getDataFormat('file.txt')).toBe(null);
-  });
-});
-
-//////////////////////////////
-// stripExtension
-//////////////////////////////
-
-describe('stripExtension', () => {
-  it('strips .md extension', () => {
-    expect(stripExtension('my-post.md')).toBe('my-post');
-  });
-
-  it('strips .markdown extension', () => {
-    expect(stripExtension('my-post.markdown')).toBe('my-post');
-  });
-
-  it('strips .mdx extension', () => {
-    expect(stripExtension('component.mdx')).toBe('component');
-  });
-
-  it('strips .mdoc extension', () => {
-    expect(stripExtension('doc.mdoc')).toBe('doc');
-  });
-
-  it('strips .markdoc extension', () => {
-    expect(stripExtension('doc.markdoc')).toBe('doc');
-  });
-
-  it('strips .json extension', () => {
-    expect(stripExtension('data.json')).toBe('data');
-  });
-
-  it('strips .yml extension', () => {
-    expect(stripExtension('config.yml')).toBe('config');
-  });
-
-  it('strips .yaml extension', () => {
-    expect(stripExtension('config.yaml')).toBe('config');
-  });
-
-  it('strips .toml extension', () => {
-    expect(stripExtension('config.toml')).toBe('config');
-  });
-
-  it('returns filename unchanged for unrecognised extensions', () => {
-    expect(stripExtension('file.txt')).toBe('file.txt');
-  });
-
-  it('only strips the last known extension in a double-extension filename', () => {
-    // Filenames with multiple dots: strip only the recognised trailing extension
-    expect(stripExtension('my.post.md')).toBe('my.post');
-  });
-});
-
-//////////////////////////////
-// getDefaultExtension
-//////////////////////////////
-
-describe('getDefaultExtension', () => {
-  it('returns .md as the default extension for md', () => {
-    expect(getDefaultExtension('md')).toBe('.md');
-  });
-
-  it('returns .mdx as the default extension for mdx', () => {
-    expect(getDefaultExtension('mdx')).toBe('.mdx');
-  });
-
-  it('returns .mdoc as the default extension for markdoc', () => {
-    expect(getDefaultExtension('markdoc')).toBe('.mdoc');
-  });
-
-  it('returns .json as the default extension for json', () => {
-    expect(getDefaultExtension('json')).toBe('.json');
-  });
-
-  it('returns .yml as the default extension for yaml', () => {
-    expect(getDefaultExtension('yaml')).toBe('.yml');
-  });
-
-  it('returns .toml as the default extension for toml', () => {
-    expect(getDefaultExtension('toml')).toBe('.toml');
-  });
-
-  it('returns null for unknown type identifiers', () => {
-    expect(getDefaultExtension('unknown')).toBe(null);
-  });
-});

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

@@ -1,87 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { splitFrontmatter } from '../../../../src/client/js/utils/frontmatter';
-
-describe('splitFrontmatter', () => {
-  it('splits valid YAML frontmatter and body', () => {
-    const content = '---\ntitle: Hello\n---\nBody text here.';
-    const result = splitFrontmatter(content);
-    // slice(4, closeIndex) stops before the \n that precedes ---
-    expect(result.rawFrontmatter).toBe('title: Hello');
-    expect(result.body).toBe('Body text here.');
-  });
-
-  it('returns an empty body when there is only frontmatter', () => {
-    const content = '---\ntitle: No Body\n---\n';
-    const result = splitFrontmatter(content);
-    expect(result.rawFrontmatter).toBe('title: No Body');
-    expect(result.body).toBe('');
-  });
-
-  it('handles frontmatter with no trailing newline (ends with ---)', () => {
-    // endsWith('\n---') branch: slice(4, length - 4) trims the leading newline of the delimiter
-    const content = '---\ntitle: EOF\n---';
-    const result = splitFrontmatter(content);
-    expect(result.rawFrontmatter).toBe('title: EOF');
-    expect(result.body).toBe('');
-  });
-
-  it('returns empty frontmatter and full content when no frontmatter delimiter is present', () => {
-    const content = 'Just plain body text.';
-    const result = splitFrontmatter(content);
-    expect(result.rawFrontmatter).toBe('');
-    expect(result.body).toBe('Just plain body text.');
-  });
-
-  it('returns empty frontmatter and full content for an empty string', () => {
-    const result = splitFrontmatter('');
-    expect(result.rawFrontmatter).toBe('');
-    expect(result.body).toBe('');
-  });
-
-  it('rejects a horizontal rule (----) at the start — not treated as frontmatter', () => {
-    const content = '----\ntitle: Nope\n---\nBody.';
-    const result = splitFrontmatter(content);
-    expect(result.rawFrontmatter).toBe('');
-    expect(result.body).toBe(content);
-  });
-
-  it('strips a leading BOM character before processing', () => {
-    const content = '\uFEFF---\ntitle: BOM\n---\nBody.';
-    const result = splitFrontmatter(content);
-    expect(result.rawFrontmatter).toBe('title: BOM');
-    expect(result.body).toBe('Body.');
-  });
-
-  it('normalises CRLF line endings before processing', () => {
-    const content = '---\r\ntitle: CRLF\r\n---\r\nBody.';
-    const result = splitFrontmatter(content);
-    expect(result.rawFrontmatter).toBe('title: CRLF');
-    expect(result.body).toBe('Body.');
-  });
-
-  it('returns empty frontmatter when the closing delimiter is missing', () => {
-    // No closing --- so the entire content is treated as body
-    const content = '---\ntitle: Unclosed';
-    const result = splitFrontmatter(content);
-    expect(result.rawFrontmatter).toBe('');
-    expect(result.body).toBe(content);
-  });
-
-  it('treats content starting with --- but missing a newline as a non-match', () => {
-    // "---" without an immediate newline is not a valid opening delimiter
-    const content = '--- title: Inline';
-    const result = splitFrontmatter(content);
-    expect(result.rawFrontmatter).toBe('');
-    expect(result.body).toBe(content);
-  });
-
-  it('handles multiline frontmatter with body correctly', () => {
-    const content =
-      '---\ntitle: Multi\nauthor: Jane\ntags:\n  - a\n  - b\n---\n# Heading\n\nParagraph.';
-    const result = splitFrontmatter(content);
-    expect(result.rawFrontmatter).toBe(
-      'title: Multi\nauthor: Jane\ntags:\n  - a\n  - b',
-    );
-    expect(result.body).toBe('# Heading\n\nParagraph.');
-  });
-});

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

@@ -1,318 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  resolveFieldType,
-  createDefaultValue,
-  extractTabs,
-  getFieldsForTab,
-  getByPath,
-  setByPath,
-} from '../../../../src/client/js/utils/schema-utils';
-
-//////////////////////////////
-// resolveFieldType
-//////////////////////////////
-
-describe('resolveFieldType', () => {
-  it('resolves type: string to kind: string', () => {
-    expect(resolveFieldType({ type: 'string' })).toEqual({ kind: 'string' });
-  });
-
-  it('resolves type: number to kind: number', () => {
-    expect(resolveFieldType({ type: 'number' })).toEqual({ kind: 'number' });
-  });
-
-  it('resolves type: integer to kind: number', () => {
-    expect(resolveFieldType({ type: 'integer' })).toEqual({ kind: 'number' });
-  });
-
-  it('resolves type: boolean to kind: boolean', () => {
-    expect(resolveFieldType({ type: 'boolean' })).toEqual({ kind: 'boolean' });
-  });
-
-  it('resolves type: array to kind: array', () => {
-    expect(resolveFieldType({ type: 'array' })).toEqual({ kind: 'array' });
-  });
-
-  it('resolves type: object to kind: object', () => {
-    expect(resolveFieldType({ type: 'object' })).toEqual({ kind: 'object' });
-  });
-
-  it('resolves string with format: date-time to kind: date', () => {
-    expect(resolveFieldType({ type: 'string', format: 'date-time' })).toEqual({
-      kind: 'date',
-    });
-  });
-
-  it('resolves string with enum values to kind: enum with options', () => {
-    const result = resolveFieldType({ type: 'string', enum: ['a', 'b', 'c'] });
-    expect(result).toEqual({ kind: 'enum', options: ['a', 'b', 'c'] });
-  });
-
-  it('resolves unknown type to kind: unknown', () => {
-    expect(resolveFieldType({ type: 'bogus' })).toEqual({ kind: 'unknown' });
-  });
-
-  it('resolves schema with no type to kind: unknown', () => {
-    expect(resolveFieldType({})).toEqual({ kind: 'unknown' });
-  });
-
-  it('unwraps nullable anyOf and marks nullable: true', () => {
-    const schema = {
-      anyOf: [{ type: 'string' }, { type: 'null' }],
-    };
-    expect(resolveFieldType(schema)).toEqual({
-      kind: 'string',
-      nullable: true,
-    });
-  });
-
-  it('unwraps nullable anyOf for date-time and marks nullable: true', () => {
-    const schema = {
-      anyOf: [{ type: 'string', format: 'date-time' }, { type: 'null' }],
-    };
-    expect(resolveFieldType(schema)).toEqual({ kind: 'date', nullable: true });
-  });
-
-  it('date-time format takes precedence over enum when both present', () => {
-    // format is checked before enum in the implementation
-    const result = resolveFieldType({
-      type: 'string',
-      format: 'date-time',
-      enum: ['x'],
-    });
-    expect(result.kind).toBe('date');
-  });
-});
-
-//////////////////////////////
-// createDefaultValue
-//////////////////////////////
-
-describe('createDefaultValue', () => {
-  it('returns an explicit schema default when present', () => {
-    expect(createDefaultValue({ type: 'string', default: 'hello' })).toBe(
-      'hello',
-    );
-  });
-
-  it('returns an explicit default of false (falsy default honoured)', () => {
-    expect(createDefaultValue({ type: 'boolean', default: false })).toBe(false);
-  });
-
-  it('returns empty string for type: string', () => {
-    expect(createDefaultValue({ type: 'string' })).toBe('');
-  });
-
-  it('returns 0 for type: number', () => {
-    expect(createDefaultValue({ type: 'number' })).toBe(0);
-  });
-
-  it('returns 0 for type: integer', () => {
-    expect(createDefaultValue({ type: 'integer' })).toBe(0);
-  });
-
-  it('returns false for type: boolean', () => {
-    expect(createDefaultValue({ type: 'boolean' })).toBe(false);
-  });
-
-  it('returns [] for type: array', () => {
-    expect(createDefaultValue({ type: 'array' })).toEqual([]);
-  });
-
-  it('returns {} for type: object with no properties', () => {
-    expect(createDefaultValue({ type: 'object' })).toEqual({});
-  });
-
-  it('recursively builds defaults for object properties', () => {
-    const schema = {
-      type: 'object',
-      properties: {
-        name: { type: 'string' },
-        count: { type: 'number' },
-        active: { type: 'boolean' },
-      },
-    };
-    expect(createDefaultValue(schema)).toEqual({
-      name: '',
-      count: 0,
-      active: false,
-    });
-  });
-
-  it('returns null for a nullable anyOf schema', () => {
-    const schema = { anyOf: [{ type: 'string' }, { type: 'null' }] };
-    expect(createDefaultValue(schema)).toBeNull();
-  });
-
-  it('returns null for an unrecognised type', () => {
-    expect(createDefaultValue({ type: 'bogus' })).toBeNull();
-  });
-
-  it('returns null for an empty schema', () => {
-    expect(createDefaultValue({})).toBeNull();
-  });
-});
-
-//////////////////////////////
-// extractTabs
-//////////////////////////////
-
-describe('extractTabs', () => {
-  it('returns an empty array when the schema has no properties', () => {
-    expect(extractTabs({})).toEqual([]);
-  });
-
-  it('returns an empty array when no fields have a tab array', () => {
-    const schema = { properties: { title: { type: 'string' } } };
-    expect(extractTabs(schema)).toEqual([]);
-  });
-
-  it('returns sorted, deduplicated tab names', () => {
-    const schema = {
-      properties: {
-        title: { type: 'string', tab: ['Content'] },
-        slug: { type: 'string', tab: ['SEO', 'Content'] },
-        date: { type: 'string', tab: ['Metadata'] },
-      },
-    };
-    expect(extractTabs(schema)).toEqual(['Content', 'Metadata', 'SEO']);
-  });
-
-  it('deduplicates tab names appearing across multiple fields', () => {
-    const schema = {
-      properties: {
-        a: { tab: ['Shared'] },
-        b: { tab: ['Shared'] },
-      },
-    };
-    expect(extractTabs(schema)).toEqual(['Shared']);
-  });
-
-  it('ignores fields whose tab value is not an array', () => {
-    const schema = {
-      properties: {
-        a: { tab: 'not-an-array' },
-        b: { tab: ['Real'] },
-      },
-    };
-    expect(extractTabs(schema)).toEqual(['Real']);
-  });
-});
-
-//////////////////////////////
-// getFieldsForTab
-//////////////////////////////
-
-describe('getFieldsForTab', () => {
-  const schema = {
-    properties: {
-      title: { type: 'string', tab: ['Content'] },
-      slug: { type: 'string', tab: ['SEO'] },
-      date: { type: 'string', tab: ['Metadata', 'Content'] },
-      $schema: { type: 'string' },
-    },
-  };
-
-  it('returns all field names (excluding $schema) when tab is null', () => {
-    const result = getFieldsForTab(schema, null);
-    expect(result).toContain('title');
-    expect(result).toContain('slug');
-    expect(result).toContain('date');
-    expect(result).not.toContain('$schema');
-  });
-
-  it('returns only fields belonging to the given tab', () => {
-    expect(getFieldsForTab(schema, 'Content')).toEqual(['title', 'date']);
-  });
-
-  it('returns the correct subset for SEO tab', () => {
-    expect(getFieldsForTab(schema, 'SEO')).toEqual(['slug']);
-  });
-
-  it('returns an empty array for a tab with no matching fields', () => {
-    expect(getFieldsForTab(schema, 'NonExistent')).toEqual([]);
-  });
-
-  it('returns an empty array when the schema has no properties', () => {
-    expect(getFieldsForTab({}, 'Content')).toEqual([]);
-  });
-});
-
-//////////////////////////////
-// getByPath
-//////////////////////////////
-
-describe('getByPath', () => {
-  it('returns the root object for an empty path', () => {
-    const obj = { a: 1 };
-    expect(getByPath(obj, [])).toBe(obj);
-  });
-
-  it('reads a top-level property by key', () => {
-    expect(getByPath({ name: 'Alice' }, ['name'])).toBe('Alice');
-  });
-
-  it('traverses nested objects', () => {
-    const obj = { a: { b: { c: 42 } } };
-    expect(getByPath(obj, ['a', 'b', 'c'])).toBe(42);
-  });
-
-  it('reads array elements by numeric index', () => {
-    const obj = { items: ['x', 'y', 'z'] };
-    expect(getByPath(obj, ['items', 1])).toBe('y');
-  });
-
-  it('returns undefined when a segment is missing', () => {
-    expect(getByPath({ a: 1 }, ['b', 'c'])).toBeUndefined();
-  });
-
-  it('returns undefined when traversing through null', () => {
-    expect(getByPath({ a: null }, ['a', 'b'])).toBeUndefined();
-  });
-
-  it('returns undefined when traversing through undefined', () => {
-    expect(getByPath({ a: undefined }, ['a', 'b'])).toBeUndefined();
-  });
-});
-
-//////////////////////////////
-// setByPath
-//////////////////////////////
-
-describe('setByPath', () => {
-  it('sets a top-level property', () => {
-    const obj: Record<string, unknown> = {};
-    setByPath(obj, ['name'], 'Alice');
-    expect(obj['name']).toBe('Alice');
-  });
-
-  it('sets a deeply nested property, creating intermediates', () => {
-    const obj: Record<string, unknown> = {};
-    setByPath(obj, ['a', 'b', 'c'], 99);
-    expect((obj['a'] as Record<string, unknown>)['b']).toEqual({ c: 99 });
-  });
-
-  it('overwrites an existing value', () => {
-    const obj = { score: 1 };
-    setByPath(obj, ['score'], 100);
-    expect(obj['score']).toBe(100);
-  });
-
-  it('sets a value at a numeric array index', () => {
-    const obj: Record<string, unknown> = { items: ['a', 'b', 'c'] };
-    setByPath(obj, ['items', 1], 'X');
-    expect((obj['items'] as string[])[1]).toBe('X');
-  });
-
-  it('does nothing for an empty path', () => {
-    const obj = { a: 1 };
-    setByPath(obj, [], 'should-not-apply');
-    expect(obj).toEqual({ a: 1 });
-  });
-
-  it('creates missing intermediate objects', () => {
-    const obj: Record<string, unknown> = {};
-    setByPath(obj, ['x', 'y'], 'deep');
-    expect(obj).toEqual({ x: { y: 'deep' } });
-  });
-});