nebula-cms 0.1.3 → 0.1.5

package/{src/client/js/utils/file-types.ts → dist/client/js/utils/file-types.js}

@@ -4,158 +4,128 @@
  * (storage adapters, orchestrator worker, editor, publish handler) derive
  * extension lists, category, and serialization format from this registry.
  */
-
-// Configuration for a single supported file type.
-export type FileTypeConfig = {
-  // All file extensions associated with this type, first entry is the default.
-  extensions: string[];
-  // Whether this type has a body editor (markdown/MDX/Markdoc).
-  hasBody: boolean;
-  // Whether the file holds frontmatter+body or pure data.
-  category: 'frontmatter' | 'data';
-  // For data files, which serialization format to use.
-  dataFormat?: 'json' | 'yaml' | 'toml';
-};
-
 // Registry mapping type identifiers (as used in schema `files` arrays) to their config.
-export const FILE_TYPES: Record<string, FileTypeConfig> = {
-  md: {
-    extensions: ['.md', '.markdown'],
-    hasBody: true,
-    category: 'frontmatter',
-  },
-  mdx: {
-    extensions: ['.mdx'],
-    hasBody: true,
-    category: 'frontmatter',
-  },
-  markdoc: {
-    extensions: ['.mdoc', '.markdoc'],
-    hasBody: true,
-    category: 'frontmatter',
-  },
-  json: {
-    extensions: ['.json'],
-    hasBody: false,
-    category: 'data',
-    dataFormat: 'json',
-  },
-  yaml: {
-    extensions: ['.yml', '.yaml'],
-    hasBody: false,
-    category: 'data',
-    dataFormat: 'yaml',
-  },
-  toml: {
-    extensions: ['.toml'],
-    hasBody: false,
-    category: 'data',
-    dataFormat: 'toml',
-  },
+export const FILE_TYPES = {
+    md: {
+        extensions: ['.md', '.markdown'],
+        hasBody: true,
+        category: 'frontmatter',
+    },
+    mdx: {
+        extensions: ['.mdx'],
+        hasBody: true,
+        category: 'frontmatter',
+    },
+    markdoc: {
+        extensions: ['.mdoc', '.markdoc'],
+        hasBody: true,
+        category: 'frontmatter',
+    },
+    json: {
+        extensions: ['.json'],
+        hasBody: false,
+        category: 'data',
+        dataFormat: 'json',
+    },
+    yaml: {
+        extensions: ['.yml', '.yaml'],
+        hasBody: false,
+        category: 'data',
+        dataFormat: 'yaml',
+    },
+    toml: {
+        extensions: ['.toml'],
+        hasBody: false,
+        category: 'data',
+        dataFormat: 'toml',
+    },
 };
-
 /*
 //////////////////////////////
 // Extension reverse-lookup map
 // Built once at module load for O(1) extension-to-config lookups.
 //////////////////////////////
 */
-
 // Maps each known extension to its FileTypeConfig.
-const extensionMap = new Map<string, FileTypeConfig>();
-
+const extensionMap = new Map();
 // Maps each known extension to its type identifier (e.g. '.md' -> 'md').
-const extensionToTypeID = new Map<string, string>();
-
+const extensionToTypeID = new Map();
 for (const [typeId, config] of Object.entries(FILE_TYPES)) {
-  for (const ext of config.extensions) {
-    extensionMap.set(ext, config);
-    extensionToTypeID.set(ext, typeId);
-  }
+    for (const ext of config.extensions) {
+        extensionMap.set(ext, config);
+        extensionToTypeID.set(ext, typeId);
+    }
 }
-
 /*
 //////////////////////////////
 // Helper: extract extension
 //////////////////////////////
 */
-
 /**
  * Extracts the last dot-prefixed extension from a filename, or an empty string if none.
  * @param {string} filename - The filename to extract the extension from
  * @return {string} The extension including the leading dot (e.g. '.md'), or ''
  */
-function getExtension(filename: string): string {
-  const idx = filename.lastIndexOf('.');
-  if (idx === -1) return '';
-  return filename.slice(idx);
+function getExtension(filename) {
+    const idx = filename.lastIndexOf('.');
+    if (idx === -1)
+        return '';
+    return filename.slice(idx);
 }
-
 /*
 //////////////////////////////
 // Exported helpers
 //////////////////////////////
 */
-
 /**
  * Resolves a schema's `files` array of type identifiers to a flat list of file extensions.
  * Used by storage adapters for file discovery filtering.
  * @param {Record<string, unknown>} schema - A collection JSON Schema with an optional `files` array
  * @return {string[]} Ordered list of extensions (e.g. ['.md', '.markdown', '.json'])
  */
-export function getExtensionsForSchema(
-  schema: Record<string, unknown>,
-): string[] {
-  const files = schema['files'];
-  if (!Array.isArray(files)) return [];
-
-  const extensions: string[] = [];
-  for (const typeId of files as string[]) {
-    const config = FILE_TYPES[typeId];
-    if (config) {
-      extensions.push(...config.extensions);
+export function getExtensionsForSchema(schema) {
+    const files = schema['files'];
+    if (!Array.isArray(files))
+        return [];
+    const extensions = [];
+    for (const typeId of files) {
+        const config = FILE_TYPES[typeId];
+        if (config) {
+            extensions.push(...config.extensions);
+        }
     }
-  }
-  return extensions;
+    return extensions;
 }
-
 /**
  * Returns whether a file should show the body editor panel.
  * True for markdown, MDX, and Markdoc files; false for pure data files.
  * @param {string} filename - The filename to check
  * @return {boolean} True if the file type has a body editor
  */
-export function hasBodyEditor(filename: string): boolean {
-  const config = extensionMap.get(getExtension(filename));
-  return config?.hasBody ?? false;
+export function hasBodyEditor(filename) {
+    const config = extensionMap.get(getExtension(filename));
+    return config?.hasBody ?? false;
 }
-
 /**
  * Returns the category of a file based on its extension.
  * Used to determine whether to render frontmatter fields or data-only fields.
  * @param {string} filename - The filename to categorise
  * @return {'frontmatter' | 'data' | null} The file category, or null for unrecognised extensions
  */
-export function getFileCategory(
-  filename: string,
-): 'frontmatter' | 'data' | null {
-  const config = extensionMap.get(getExtension(filename));
-  return config?.category ?? null;
+export function getFileCategory(filename) {
+    const config = extensionMap.get(getExtension(filename));
+    return config?.category ?? null;
 }
-
 /**
  * Returns the serialization format for a data file.
  * Returns null for frontmatter files and unrecognised extensions.
  * @param {string} filename - The filename to inspect
  * @return {'json' | 'yaml' | 'toml' | null} The data format, or null if not a data file
  */
-export function getDataFormat(
-  filename: string,
-): 'json' | 'yaml' | 'toml' | null {
-  const config = extensionMap.get(getExtension(filename));
-  return config?.dataFormat ?? null;
+export function getDataFormat(filename) {
+    const config = extensionMap.get(getExtension(filename));
+    return config?.dataFormat ?? null;
 }
-
 /**
  * Strips the file extension from a filename when the extension is a known type.
  * Returns the filename unchanged if the extension is not recognised.
@@ -163,30 +133,28 @@ export function getDataFormat(
  * @param {string} filename - The filename to strip the extension from
  * @return {string} The filename without its known extension, or the original filename
  */
-export function stripExtension(filename: string): string {
-  const ext = getExtension(filename);
-  if (ext && extensionMap.has(ext)) {
-    return filename.slice(0, filename.length - ext.length);
-  }
-  return filename;
+export function stripExtension(filename) {
+    const ext = getExtension(filename);
+    if (ext && extensionMap.has(ext)) {
+        return filename.slice(0, filename.length - ext.length);
+    }
+    return filename;
 }
-
 /**
  * Returns the default (first) file extension for a given type identifier.
  * Used when creating new files to pick the canonical extension for a format.
  * @param {string} type - A type identifier (e.g. 'md', 'yaml', 'toml')
  * @return {string | null} The default extension including the leading dot, or null for unknown types
  */
-export function getDefaultExtension(type: string): string | null {
-  return FILE_TYPES[type]?.extensions[0] ?? null;
+export function getDefaultExtension(type) {
+    return FILE_TYPES[type]?.extensions[0] ?? null;
 }
-
 /**
  * Returns the type identifier for a given filename by looking up its extension.
  * Used when the active file's type must be determined for the format selector.
  * @param {string} filename - The filename to look up
  * @return {string | null} The type identifier (e.g. 'md', 'yaml'), or null for unrecognised extensions
  */
-export function getTypeForFilename(filename: string): string | null {
-  return extensionToTypeID.get(getExtension(filename)) ?? null;
+export function getTypeForFilename(filename) {
+    return extensionToTypeID.get(getExtension(filename)) ?? null;
 }

package/dist/client/js/utils/format.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts a property name string to Title Case for display in form labels.
+ * Splits on camelCase boundaries, hyphens, and underscores, then capitalizes each word.
+ * @param {string} str - The raw property name to convert (e.g., "firstName", "last-name", "zip_code")
+ * @return {string} The title-cased display string (e.g., "First Name", "Last Name", "Zip Code")
+ */
+export declare function toTitleCase(str: string): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/client/js/utils/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../../src/client/js/utils/format.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAK/C"}

package/{src/client/js/utils/format.ts → dist/client/js/utils/format.js}

@@ -1,16 +1,15 @@
 /*
  * Display formatting utilities for property names and labels.
  */
-
 /**
  * Converts a property name string to Title Case for display in form labels.
  * Splits on camelCase boundaries, hyphens, and underscores, then capitalizes each word.
  * @param {string} str - The raw property name to convert (e.g., "firstName", "last-name", "zip_code")
  * @return {string} The title-cased display string (e.g., "First Name", "Last Name", "Zip Code")
  */
-export function toTitleCase(str: string): string {
-  return str
-    .replace(/([a-z])([A-Z])/g, '$1 $2')
-    .replace(/[-_]/g, ' ')
-    .replace(/\b\w/g, (c) => c.toUpperCase());
+export function toTitleCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/[-_]/g, ' ')
+        .replace(/\b\w/g, (c) => c.toUpperCase());
 }

package/dist/client/js/utils/frontmatter.d.ts

@@ -0,0 +1,12 @@
+export type SplitResult = {
+    rawFrontmatter: string;
+    body: string;
+};
+/**
+ * Splits a markdown/MDX file into raw YAML frontmatter and body content.
+ * Handles BOM stripping, CRLF normalization, and horizontal rule rejection.
+ * @param {string} content - Raw file content
+ * @return {SplitResult} The separated frontmatter and body strings
+ */
+export declare function splitFrontmatter(content: string): SplitResult;
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/client/js/utils/frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.d.ts","sourceRoot":"","sources":["../../../../src/client/js/utils/frontmatter.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,WAAW,GAAG;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CAyB7D"}

package/dist/client/js/utils/frontmatter.js

@@ -0,0 +1,29 @@
+/**
+ * Splits a markdown/MDX file into raw YAML frontmatter and body content.
+ * Handles BOM stripping, CRLF normalization, and horizontal rule rejection.
+ * @param {string} content - Raw file content
+ * @return {SplitResult} The separated frontmatter and body strings
+ */
+export function splitFrontmatter(content) {
+    let str = content.startsWith('\uFEFF') ? content.slice(1) : content;
+    str = str.replace(/\r\n/g, '\n');
+    // Reject horizontal rules (----) and content not starting with frontmatter delimiter
+    if (str.startsWith('----') || !str.startsWith('---\n')) {
+        return { rawFrontmatter: '', body: str };
+    }
+    const closeIndex = str.indexOf('\n---\n', 3);
+    if (closeIndex === -1) {
+        // Check for --- at end of file with no trailing newline
+        if (str.endsWith('\n---')) {
+            return {
+                rawFrontmatter: str.slice(4, str.length - 4),
+                body: '',
+            };
+        }
+        return { rawFrontmatter: '', body: str };
+    }
+    return {
+        rawFrontmatter: str.slice(4, closeIndex),
+        body: str.slice(closeIndex + 5),
+    };
+}

package/dist/client/js/utils/schema-utils.d.ts

@@ -0,0 +1,110 @@
+export type SchemaNode = Record<string, unknown>;
+/**
+ * Discriminated union describing the resolved type of a schema field. All variants carry an optional `nullable` flag set when the field was expressed as `anyOf: [<type>, { type: 'null' }]`.
+ */
+export type FieldType = {
+    kind: 'string';
+    nullable?: boolean;
+} | {
+    kind: 'number';
+    nullable?: boolean;
+} | {
+    kind: 'boolean';
+    nullable?: boolean;
+} | {
+    kind: 'date';
+    nullable?: boolean;
+} | {
+    kind: 'enum';
+    options: string[];
+    nullable?: boolean;
+} | {
+    kind: 'array';
+    nullable?: boolean;
+} | {
+    kind: 'object';
+    nullable?: boolean;
+} | {
+    kind: 'unknown';
+    nullable?: boolean;
+};
+/**
+ * A path segment used to address nested values. Strings address object keys; numbers address array indices.
+ */
+export type PathSegment = string | number;
+/**
+ * Resolves a JSON Schema node to a `FieldType` discriminated union.
+ * Handles anyOf nullable unwrapping, enum detection, and date-time format.
+ * @param {SchemaNode} schema - The JSON Schema node to resolve
+ * @return {FieldType} The resolved field type descriptor
+ */
+export declare function resolveFieldType(schema: SchemaNode): FieldType;
+/**
+ * Scans an object schema's properties for `tab` arrays and returns a sorted, deduplicated list of all tab names found.
+ * @param {SchemaNode} schema - A JSON Schema node with an optional `properties` map
+ * @return {string[]} Sorted, deduplicated list of tab names
+ */
+export declare function extractTabs(schema: SchemaNode): string[];
+/**
+ * Returns a type-appropriate default value for a given JSON Schema node.
+ * Honors `schema.default` when present, returns null for nullable types, and recurses into object properties.
+ * @param {SchemaNode} schema - The JSON Schema node to generate a default value for
+ * @return {unknown} A default value appropriate for the schema type
+ */
+export declare function createDefaultValue(schema: SchemaNode): unknown;
+/**
+ * Reads a deeply nested value from an object by following path segments.
+ * Returns `undefined` if any segment along the path is missing.
+ * @param {unknown} obj - The root object to traverse
+ * @param {PathSegment[]} path - Ordered path segments (string keys or numeric indices)
+ * @return {unknown} The value at the resolved path, or undefined if any segment is missing
+ */
+export declare function getByPath(obj: unknown, path: PathSegment[]): unknown;
+/**
+ * Sets a deeply nested value in an object by following path segments, creating intermediate objects as needed.
+ * @param {unknown} obj - The root object to mutate
+ * @param {PathSegment[]} path - Ordered path segments (string keys or numeric indices)
+ * @param {unknown} value - The value to assign at the resolved path
+ * @return {void}
+ */
+export declare function setByPath(obj: unknown, path: PathSegment[], value: unknown): void;
+/**
+ * Returns property names from a schema that belong to the given tab.
+ * When `tab` is `null`, all property names are returned (no filtering — every field appears in the catch-all Metadata view).
+ * @param {SchemaNode} schema - A JSON Schema node with an optional `properties` map
+ * @param {string | null} tab - Tab name to filter by, or `null` to return all fields
+ * @return {string[]} Array of property names belonging to the specified tab
+ */
+export declare function getFieldsForTab(schema: SchemaNode, tab: string | null): string[];
+/**
+ * Extracts the `properties` map from a schema node, with a safe cast.
+ * @param {SchemaNode} schema - A JSON Schema node
+ * @return {Record<string, SchemaNode> | undefined} The properties map, or undefined if absent
+ */
+export declare function getProperties(schema: SchemaNode): Record<string, SchemaNode> | undefined;
+/**
+ * Extracts the `required` array from a schema node, returning an empty array if absent.
+ * @param {SchemaNode} schema - A JSON Schema node
+ * @return {string[]} Array of required property names
+ */
+export declare function getRequiredFields(schema: SchemaNode): string[];
+/**
+ * Returns whether a schema node is marked as read-only.
+ * @param {SchemaNode} schema - A JSON Schema node
+ * @return {boolean} True if the schema has readOnly set to true
+ */
+export declare function isReadOnly(schema: SchemaNode): boolean;
+/**
+ * Returns whether a schema node was unwrapped from a nullable anyOf and flagged as nullable by SchemaField.
+ * @param {SchemaNode} schema - A JSON Schema node (possibly annotated with _nullable)
+ * @return {boolean} True if the schema has the _nullable annotation
+ */
+export declare function isNullable(schema: SchemaNode): boolean;
+/**
+ * Returns the display label for a schema field — the schema title if present, otherwise the property name converted to title case.
+ * @param {SchemaNode} schema - A JSON Schema node
+ * @param {string} name - The raw property name used as a fallback
+ * @return {string} The human-readable label
+ */
+export declare function getLabel(schema: SchemaNode, name: string): string;
+//# sourceMappingURL=schema-utils.d.ts.map

package/dist/client/js/utils/schema-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-utils.d.ts","sourceRoot":"","sources":["../../../../src/client/js/utils/schema-utils.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEjD;;GAEG;AACH,MAAM,MAAM,SAAS,GACjB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GACvC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GACvD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GACrC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAE5C;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,CAAC;AAQ1C;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,CAgC9D;AAQD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,EAAE,CAgBxD;AAQD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CA+B9D;AAQD;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,GAAG,OAAO,CAOpE;AAQD;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE,WAAW,EAAE,EACnB,KAAK,EAAE,OAAO,GACb,IAAI,CAeN;AAQD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,UAAU,EAClB,GAAG,EAAE,MAAM,GAAG,IAAI,GACjB,MAAM,EAAE,CAiBV;AAQD;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,UAAU,GACjB,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,SAAS,CAExC;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,EAAE,CAI9D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAEtD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAEtD;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjE"}