@object-ui/core 0.3.0

package/src/registry/Registry.ts

@@ -0,0 +1,77 @@
+import type { SchemaNode } from '../types';
+
+export type ComponentRenderer<T = any> = T;
+
+export type ComponentInput = {
+  name: string;
+  type: 'string' | 'number' | 'boolean' | 'enum' | 'array' | 'object' | 'color' | 'date' | 'code' | 'file' | 'slot';
+  label?: string;
+  defaultValue?: any;
+  required?: boolean;
+  enum?: string[] | { label: string; value: any }[];
+  description?: string;
+  advanced?: boolean;
+  inputType?: string;
+};
+
+export type ComponentMeta = {
+  label?: string; // Display name in designer
+  icon?: string; // Icon name or svg string
+  category?: string; // Grouping category
+  inputs?: ComponentInput[];
+  defaultProps?: Record<string, any>; // Default props when dropped
+  defaultChildren?: SchemaNode[]; // Default children when dropped
+  examples?: Record<string, any>; // Example configurations
+  isContainer?: boolean; // Whether the component can have children
+  resizable?: boolean; // Whether the component can be resized in the designer
+  resizeConstraints?: {
+    width?: boolean;
+    height?: boolean;
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+  };
+};
+
+export type ComponentConfig<T = any> = ComponentMeta & {
+  type: string;
+  component: ComponentRenderer<T>;
+};
+
+export class Registry<T = any> {
+  private components = new Map<string, ComponentConfig<T>>();
+
+  register(type: string, component: ComponentRenderer<T>, meta?: ComponentMeta) {
+    if (this.components.has(type)) {
+      console.warn(`Component type "${type}" is already registered. Overwriting.`);
+    }
+    this.components.set(type, {
+      type,
+      component,
+      ...meta
+    });
+  }
+
+  get(type: string): ComponentRenderer<T> | undefined {
+    return this.components.get(type)?.component;
+  }
+
+  getConfig(type: string): ComponentConfig<T> | undefined {
+    return this.components.get(type);
+  }
+
+  has(type: string): boolean {
+    return this.components.has(type);
+  }
+  
+  getAllTypes(): string[] {
+    return Array.from(this.components.keys());
+  }
+
+  getAllConfigs(): ComponentConfig<T>[] {
+    return Array.from(this.components.values());
+  }
+}
+
+export const ComponentRegistry = new Registry<any>();

package/src/types/index.d.ts

@@ -0,0 +1,12 @@
+export interface SchemaNode {
+    type: string;
+    id?: string;
+    className?: string;
+    data?: any;
+    body?: SchemaNode | SchemaNode[];
+    [key: string]: any;
+}
+export interface ComponentRendererProps {
+    schema: SchemaNode;
+    [key: string]: any;
+}

package/src/types/index.js

@@ -0,0 +1 @@
+export {};

package/src/types/index.ts

@@ -0,0 +1,13 @@
+export interface SchemaNode {
+  type: string;
+  id?: string;
+  className?: string;
+  data?: any;
+  body?: SchemaNode | SchemaNode[];
+  [key: string]: any;
+}
+
+export interface ComponentRendererProps {
+  schema: SchemaNode;
+  [key: string]: any;
+}

package/src/validation/schema-validator.d.ts

@@ -0,0 +1,87 @@
+/**
+ * @object-ui/core - Schema Validation
+ *
+ * Runtime validation utilities for Object UI schemas.
+ * These utilities help ensure schemas are valid before rendering.
+ *
+ * @module validation
+ * @packageDocumentation
+ */
+import type { BaseSchema } from '@object-ui/types';
+/**
+ * Validation error details
+ */
+export interface ValidationError {
+    path: string;
+    message: string;
+    type: 'error' | 'warning';
+    code?: string;
+}
+/**
+ * Validation result
+ */
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationError[];
+}
+/**
+ * Validate a complete schema
+ *
+ * @param schema - The schema to validate
+ * @param options - Validation options
+ * @returns Validation result with errors and warnings
+ *
+ * @example
+ * ```typescript
+ * const result = validateSchema({
+ *   type: 'form',
+ *   fields: [
+ *     { name: 'email', type: 'input' }
+ *   ]
+ * });
+ *
+ * if (!result.valid) {
+ *   console.error('Validation errors:', result.errors);
+ * }
+ * ```
+ */
+export declare function validateSchema(schema: any, path?: string): ValidationResult;
+/**
+ * Assert that a schema is valid, throwing an error if not
+ *
+ * @param schema - The schema to validate
+ * @throws Error if schema is invalid
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   assertValidSchema(schema);
+ *   // Schema is valid, continue rendering
+ * } catch (error) {
+ *   console.error('Invalid schema:', error.message);
+ * }
+ * ```
+ */
+export declare function assertValidSchema(schema: any): asserts schema is BaseSchema;
+/**
+ * Check if a value is a valid schema
+ *
+ * @param value - The value to check
+ * @returns True if the value is a valid schema
+ *
+ * @example
+ * ```typescript
+ * if (isValidSchema(data)) {
+ *   renderSchema(data);
+ * }
+ * ```
+ */
+export declare function isValidSchema(value: any): value is BaseSchema;
+/**
+ * Get a human-readable error summary
+ *
+ * @param result - The validation result
+ * @returns Formatted error summary
+ */
+export declare function formatValidationErrors(result: ValidationResult): string;

package/src/validation/schema-validator.js

@@ -0,0 +1,280 @@
+/**
+ * @object-ui/core - Schema Validation
+ *
+ * Runtime validation utilities for Object UI schemas.
+ * These utilities help ensure schemas are valid before rendering.
+ *
+ * @module validation
+ * @packageDocumentation
+ */
+/**
+ * Validation rules for base schema
+ */
+const BASE_SCHEMA_RULES = {
+    type: {
+        required: true,
+        validate: (value) => typeof value === 'string' && value.length > 0,
+        message: 'type must be a non-empty string'
+    },
+    id: {
+        required: false,
+        validate: (value) => typeof value === 'string',
+        message: 'id must be a string'
+    },
+    className: {
+        required: false,
+        validate: (value) => typeof value === 'string',
+        message: 'className must be a string'
+    },
+    visible: {
+        required: false,
+        validate: (value) => typeof value === 'boolean',
+        message: 'visible must be a boolean'
+    },
+    disabled: {
+        required: false,
+        validate: (value) => typeof value === 'boolean',
+        message: 'disabled must be a boolean'
+    }
+};
+/**
+ * Validate a schema against base rules
+ */
+function validateBaseSchema(schema, path = 'schema') {
+    const errors = [];
+    if (!schema || typeof schema !== 'object') {
+        errors.push({
+            path,
+            message: 'Schema must be an object',
+            type: 'error',
+            code: 'INVALID_SCHEMA'
+        });
+        return errors;
+    }
+    // Validate required and optional properties
+    Object.entries(BASE_SCHEMA_RULES).forEach(([key, rule]) => {
+        const value = schema[key];
+        if (rule.required && value === undefined) {
+            errors.push({
+                path: `${path}.${key}`,
+                message: `${key} is required`,
+                type: 'error',
+                code: 'MISSING_REQUIRED'
+            });
+        }
+        if (value !== undefined && !rule.validate(value)) {
+            errors.push({
+                path: `${path}.${key}`,
+                message: rule.message,
+                type: 'error',
+                code: 'INVALID_TYPE'
+            });
+        }
+    });
+    return errors;
+}
+/**
+ * Validate CRUD schema specific properties
+ */
+function validateCRUDSchema(schema, path = 'schema') {
+    const errors = [];
+    if (schema.type === 'crud') {
+        // Check required properties for CRUD
+        if (!schema.columns || !Array.isArray(schema.columns)) {
+            errors.push({
+                path: `${path}.columns`,
+                message: 'CRUD schema requires columns array',
+                type: 'error',
+                code: 'MISSING_COLUMNS'
+            });
+        }
+        if (!schema.api && !schema.dataSource) {
+            errors.push({
+                path: `${path}.api`,
+                message: 'CRUD schema requires api or dataSource',
+                type: 'warning',
+                code: 'MISSING_DATA_SOURCE'
+            });
+        }
+        // Validate columns
+        if (schema.columns && Array.isArray(schema.columns)) {
+            schema.columns.forEach((column, index) => {
+                if (!column.name) {
+                    errors.push({
+                        path: `${path}.columns[${index}]`,
+                        message: 'Column requires name property',
+                        type: 'error',
+                        code: 'MISSING_COLUMN_NAME'
+                    });
+                }
+            });
+        }
+        // Validate fields if present
+        if (schema.fields && Array.isArray(schema.fields)) {
+            schema.fields.forEach((field, index) => {
+                if (!field.name) {
+                    errors.push({
+                        path: `${path}.fields[${index}]`,
+                        message: 'Field requires name property',
+                        type: 'error',
+                        code: 'MISSING_FIELD_NAME'
+                    });
+                }
+            });
+        }
+    }
+    return errors;
+}
+/**
+ * Validate form schema specific properties
+ */
+function validateFormSchema(schema, path = 'schema') {
+    const errors = [];
+    if (schema.type === 'form') {
+        if (schema.fields && Array.isArray(schema.fields)) {
+            schema.fields.forEach((field, index) => {
+                if (!field.name) {
+                    errors.push({
+                        path: `${path}.fields[${index}]`,
+                        message: 'Form field requires name property',
+                        type: 'error',
+                        code: 'MISSING_FIELD_NAME'
+                    });
+                }
+                // Check for duplicate field names
+                const duplicates = schema.fields.filter((f) => f.name === field.name);
+                if (duplicates.length > 1) {
+                    errors.push({
+                        path: `${path}.fields[${index}]`,
+                        message: `Duplicate field name: ${field.name}`,
+                        type: 'warning',
+                        code: 'DUPLICATE_FIELD_NAME'
+                    });
+                }
+            });
+        }
+    }
+    return errors;
+}
+/**
+ * Validate child schemas recursively
+ */
+function validateChildren(schema, path = 'schema') {
+    const errors = [];
+    const children = schema.children || schema.body;
+    if (children) {
+        if (Array.isArray(children)) {
+            children.forEach((child, index) => {
+                if (typeof child === 'object' && child !== null) {
+                    const childResult = validateSchema(child, `${path}.children[${index}]`);
+                    errors.push(...childResult.errors, ...childResult.warnings);
+                }
+            });
+        }
+        else if (typeof children === 'object' && children !== null) {
+            const childResult = validateSchema(children, `${path}.children`);
+            errors.push(...childResult.errors, ...childResult.warnings);
+        }
+    }
+    return errors;
+}
+/**
+ * Validate a complete schema
+ *
+ * @param schema - The schema to validate
+ * @param options - Validation options
+ * @returns Validation result with errors and warnings
+ *
+ * @example
+ * ```typescript
+ * const result = validateSchema({
+ *   type: 'form',
+ *   fields: [
+ *     { name: 'email', type: 'input' }
+ *   ]
+ * });
+ *
+ * if (!result.valid) {
+ *   console.error('Validation errors:', result.errors);
+ * }
+ * ```
+ */
+export function validateSchema(schema, path = 'schema') {
+    const allErrors = [];
+    // Validate base schema
+    allErrors.push(...validateBaseSchema(schema, path));
+    // Validate type-specific schemas
+    allErrors.push(...validateCRUDSchema(schema, path));
+    allErrors.push(...validateFormSchema(schema, path));
+    // Validate children recursively
+    allErrors.push(...validateChildren(schema, path));
+    const errors = allErrors.filter(e => e.type === 'error');
+    const warnings = allErrors.filter(e => e.type === 'warning');
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings
+    };
+}
+/**
+ * Assert that a schema is valid, throwing an error if not
+ *
+ * @param schema - The schema to validate
+ * @throws Error if schema is invalid
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   assertValidSchema(schema);
+ *   // Schema is valid, continue rendering
+ * } catch (error) {
+ *   console.error('Invalid schema:', error.message);
+ * }
+ * ```
+ */
+export function assertValidSchema(schema) {
+    const result = validateSchema(schema);
+    if (!result.valid) {
+        const errorMessages = result.errors.map(e => `${e.path}: ${e.message}`).join('\n');
+        throw new Error(`Schema validation failed:\n${errorMessages}`);
+    }
+}
+/**
+ * Check if a value is a valid schema
+ *
+ * @param value - The value to check
+ * @returns True if the value is a valid schema
+ *
+ * @example
+ * ```typescript
+ * if (isValidSchema(data)) {
+ *   renderSchema(data);
+ * }
+ * ```
+ */
+export function isValidSchema(value) {
+    const result = validateSchema(value);
+    return result.valid;
+}
+/**
+ * Get a human-readable error summary
+ *
+ * @param result - The validation result
+ * @returns Formatted error summary
+ */
+export function formatValidationErrors(result) {
+    const parts = [];
+    if (result.errors.length > 0) {
+        parts.push('Errors:');
+        result.errors.forEach(error => {
+            parts.push(`  - ${error.path}: ${error.message}`);
+        });
+    }
+    if (result.warnings.length > 0) {
+        parts.push('Warnings:');
+        result.warnings.forEach(warning => {
+            parts.push(`  - ${warning.path}: ${warning.message}`);
+        });
+    }
+    return parts.join('\n');
+}