meno-core 1.0.0

package/lib/shared/utils.test.ts

@@ -0,0 +1,261 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { deepClone, wait, isEditableElement, getParentPathFromTreePath, normalizeChildrenArray } from './utils';
+
+/**
+ * utils Tests
+ * Tests shared utility functions
+ */
+
+describe('utils', () => {
+  describe('deepClone', () => {
+    test('should clone simple object', () => {
+      const obj = { a: 1, b: 'test' };
+      const cloned = deepClone(obj);
+      expect(cloned).toEqual(obj);
+      expect(cloned).not.toBe(obj);
+    });
+
+    test('should clone nested object', () => {
+      const obj = {
+        a: 1,
+        b: {
+          c: 2,
+          d: {
+            e: 3,
+          },
+        },
+      };
+      const cloned = deepClone(obj);
+      expect(cloned).toEqual(obj);
+      expect(cloned).not.toBe(obj);
+      expect(cloned.b).not.toBe(obj.b);
+      expect(cloned.b.d).not.toBe(obj.b.d);
+    });
+
+    test('should clone arrays', () => {
+      const arr = [1, 2, 3, 4];
+      const cloned = deepClone(arr);
+      expect(cloned).toEqual(arr);
+      expect(cloned).not.toBe(arr);
+    });
+
+    test('should clone nested arrays', () => {
+      const arr = [1, [2, 3], [4, [5, 6]]];
+      const cloned = deepClone(arr);
+      expect(cloned).toEqual(arr);
+      expect(cloned).not.toBe(arr);
+      expect(cloned[1]).not.toBe(arr[1]);
+    });
+
+    test('should clone mixed object and array', () => {
+      const obj = {
+        arr: [1, 2, 3],
+        nested: {
+          arr2: [4, 5],
+        },
+      };
+      const cloned = deepClone(obj);
+      expect(cloned).toEqual(obj);
+      expect(cloned.arr).not.toBe(obj.arr);
+      expect(cloned.nested.arr2).not.toBe(obj.nested.arr2);
+    });
+
+    test('should handle null values', () => {
+      const obj = { a: null, b: 'test' };
+      const cloned = deepClone(obj);
+      expect(cloned).toEqual(obj);
+    });
+
+    test('should handle boolean values', () => {
+      const obj = { a: true, b: false };
+      const cloned = deepClone(obj);
+      expect(cloned).toEqual(obj);
+    });
+
+    test('should handle number values', () => {
+      const obj = { a: 0, b: -1, c: 3.14 };
+      const cloned = deepClone(obj);
+      expect(cloned).toEqual(obj);
+    });
+
+    test('should handle empty object', () => {
+      const obj = {};
+      const cloned = deepClone(obj);
+      expect(cloned).toEqual(obj);
+      expect(cloned).not.toBe(obj);
+    });
+
+    test('should handle empty array', () => {
+      const arr: any[] = [];
+      const cloned = deepClone(arr);
+      expect(cloned).toEqual(arr);
+      expect(cloned).not.toBe(arr);
+    });
+  });
+
+  describe('wait', () => {
+    test('should wait for specified milliseconds', async () => {
+      const start = Date.now();
+      await wait(50);
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeGreaterThanOrEqual(45); // Allow some tolerance
+      expect(elapsed).toBeLessThan(100);
+    });
+
+    test('should wait for zero milliseconds', async () => {
+      const start = Date.now();
+      await wait(0);
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(10);
+    });
+
+    test('should work with multiple waits', async () => {
+      const start = Date.now();
+      await wait(20);
+      await wait(20);
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeGreaterThanOrEqual(35);
+      expect(elapsed).toBeLessThan(60);
+    });
+  });
+
+  describe('isEditableElement', () => {
+    beforeEach(() => {
+      // Clear any focused element before each test
+      if (document.activeElement instanceof HTMLElement) {
+        document.activeElement.blur();
+      }
+    });
+
+    test('should return false when no element is focused', () => {
+      expect(isEditableElement()).toBe(false);
+    });
+
+    test('should return true for input element', () => {
+      const input = document.createElement('input');
+      document.body.appendChild(input);
+      input.focus();
+      expect(isEditableElement()).toBe(true);
+      document.body.removeChild(input);
+    });
+
+    test('should return true for textarea element', () => {
+      const textarea = document.createElement('textarea');
+      document.body.appendChild(textarea);
+      textarea.focus();
+      expect(isEditableElement()).toBe(true);
+      document.body.removeChild(textarea);
+    });
+
+    test('should return true for contenteditable element', () => {
+      const div = document.createElement('div');
+      div.setAttribute('contenteditable', 'true');
+      document.body.appendChild(div);
+      div.focus();
+      expect(isEditableElement()).toBe(true);
+      document.body.removeChild(div);
+    });
+
+    test('should return false for non-editable element', () => {
+      const div = document.createElement('div');
+      document.body.appendChild(div);
+      div.focus();
+      expect(isEditableElement()).toBe(false);
+      document.body.removeChild(div);
+    });
+  });
+
+  describe('getParentPathFromTreePath', () => {
+    test('should return parent path from comma-separated string path', () => {
+      expect(getParentPathFromTreePath('0,0')).toBe('root_0');
+      expect(getParentPathFromTreePath('0,0,1')).toBe('root_0_children_0');
+    });
+
+    test('should return parent path from array path', () => {
+      expect(getParentPathFromTreePath([0, 0])).toBe('root_0');
+      expect(getParentPathFromTreePath([0, 0, 1])).toBe('root_0_children_0');
+    });
+
+    test('should return root for root path', () => {
+      expect(getParentPathFromTreePath([0])).toBe('root_0');
+      expect(getParentPathFromTreePath('0')).toBe('root_0');
+    });
+
+    test('should handle custom root path', () => {
+      expect(getParentPathFromTreePath([0], 'custom_root')).toBe('custom_root');
+    });
+
+    test('should handle deep nesting', () => {
+      expect(getParentPathFromTreePath([0, 0, 1, 2])).toBe('root_0_children_0_children_1');
+      expect(getParentPathFromTreePath([0, 1, 2, 3, 4])).toBe('root_0_children_1_children_2_children_3');
+    });
+
+    test('should handle string format deep nesting', () => {
+      expect(getParentPathFromTreePath('0,0,1,2')).toBe('root_0_children_0_children_1');
+      expect(getParentPathFromTreePath('0,1,2,3,4')).toBe('root_0_children_1_children_2_children_3');
+    });
+  });
+
+  describe('normalizeChildrenArray', () => {
+    test('should convert undefined children to empty array', () => {
+      const node: any = {};
+      normalizeChildrenArray(node);
+      expect(node.children).toEqual([]);
+    });
+
+    test('should keep existing array unchanged', () => {
+      const node = { children: [1, 2, 3] };
+      normalizeChildrenArray(node);
+      expect(node.children).toEqual([1, 2, 3]);
+    });
+
+    test('should wrap single child in array', () => {
+      const node: any = { children: 'single' };
+      normalizeChildrenArray(node);
+      expect(node.children).toEqual(['single']);
+    });
+
+    test('should wrap single object in array', () => {
+      const child = { element: 'div' };
+      const node: any = { children: child };
+      normalizeChildrenArray(node);
+      expect(node.children).toEqual([child]);
+    });
+
+    test('should handle empty array', () => {
+      const node = { children: [] };
+      normalizeChildrenArray(node);
+      expect(node.children).toEqual([]);
+    });
+
+    test('should mutate node directly', () => {
+      const node: any = { children: 'single' };
+      const original = node;
+      normalizeChildrenArray(node);
+      expect(node).toBe(original);
+      expect(node.children).toEqual(['single']);
+    });
+
+    test('should handle node with no children property', () => {
+      const node: any = { element: 'div' };
+      normalizeChildrenArray(node);
+      expect(node.children).toEqual([]);
+    });
+
+    test('should handle complex children array', () => {
+      const node = {
+        children: [
+          { element: 'div' },
+          { element: 'span' },
+          'text',
+        ],
+      };
+      normalizeChildrenArray(node);
+      expect(node.children).toEqual([
+        { element: 'div' },
+        { element: 'span' },
+        'text',
+      ]);
+    });
+  });
+});

package/lib/shared/utils.ts

@@ -0,0 +1,84 @@
+/**
+ * Shared utility functions used across the codebase
+ */
+
+import type { Path } from './pathArrayUtils';
+import { stringToPath, pathToLegacyString, getParentPath, isRootPath as isRootPathArray } from './pathArrayUtils';
+import { ROOT_0_STRING } from './pathArrayUtils';
+
+/**
+ * Deep clone an object using JSON serialization
+ * @param obj - The object to clone
+ * @returns A deep clone of the object
+ */
+export function deepClone<T>(obj: T): T {
+  try {
+    return JSON.parse(JSON.stringify(obj)) as T;
+  } catch (error) {
+    throw error;
+  }
+}
+
+/**
+ * Wait for a specified amount of time
+ * @param ms - Milliseconds to wait
+ */
+export function wait(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Check if the currently focused element is editable (input, textarea, or contenteditable)
+ * @returns true if the active element is editable
+ */
+export function isEditableElement(): boolean {
+  const activeElement = document.activeElement;
+  if (!activeElement) return false;
+  
+  return (
+    activeElement.tagName === 'INPUT' ||
+    activeElement.tagName === 'TEXTAREA' ||
+    activeElement.hasAttribute('contenteditable') ||
+    (activeElement as HTMLElement).isContentEditable
+  );
+}
+
+/**
+ * Extract the parent path from a tree path
+ * Example: root_0_children_0 -> root_0, root_0_children_0_children_1 -> root_0_children_0
+ * Also accepts array paths: [0,0] -> "root_0", [0,0,1] -> "root_0_children_0"
+ * 
+ * @param treePath - The tree path (string or Path array)
+ * @param rootPath - The root path constant (default: 'root_0')
+ * @returns The parent path, or rootPath if no parent found
+ */
+export function getParentPathFromTreePath(treePath: string | Path, rootPath: string = ROOT_0_STRING): string {
+  // Convert to array if needed
+  const pathArray = typeof treePath === 'string' ? stringToPath(treePath) : treePath;
+  
+  // Handle root paths
+  if (isRootPathArray(pathArray)) {
+    return rootPath;
+  }
+  
+  // Use array operations to get parent path
+  const parentArray = getParentPath(pathArray);
+  return pathToLegacyString(parentArray);
+}
+
+/**
+ * Normalize children property to always be an array
+ * Mutates the node object directly (for performance in large trees)
+ * Handles cases where children might be undefined, a single item, or already an array
+ * @param node - The node object with a children property (will be mutated)
+ */
+export function normalizeChildrenArray(node: { children?: any[] | any }): void {
+  if (!node.children) {
+    node.children = [];
+  } else if (!Array.isArray(node.children)) {
+    // Single child - wrap in array
+    node.children = [node.children];
+  }
+  // If already an array, no change needed
+}
+

package/lib/shared/validation/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Validation exports
+ */
+
+export * from './schemas';
+export * from './validators';
+export * from './propValidator';

package/lib/shared/validation/propValidator.test.ts

@@ -0,0 +1,178 @@
+/**
+ * Prop Validator Tests
+ * Critical path tests for prop validation
+ */
+
+import { describe, test, expect } from 'bun:test';
+import { validateComponentProps } from './propValidator';
+import type { PropDefinition } from '../types';
+
+describe('Prop Validator', () => {
+  describe('Valid props pass validation', () => {
+    test('string prop with valid value', () => {
+      const propDefs: Record<string, PropDefinition> = {
+        title: { type: 'string', default: 'Hello' },
+      };
+      const passedProps = { title: 'World' };
+      
+      const result = validateComponentProps(propDefs, passedProps);
+      
+      expect(result.valid).toBe(true);
+      expect(result.props.title).toBe('World');
+    });
+
+    test('number prop with valid value', () => {
+      const propDefs: Record<string, PropDefinition> = {
+        count: { type: 'number', default: 0 },
+      };
+      const passedProps = { count: 42 };
+      
+      const result = validateComponentProps(propDefs, passedProps);
+      
+      expect(result.valid).toBe(true);
+      expect(result.props.count).toBe(42);
+    });
+
+    test('boolean prop with valid value', () => {
+      const propDefs: Record<string, PropDefinition> = {
+        enabled: { type: 'boolean', default: false },
+      };
+      const passedProps = { enabled: true };
+      
+      const result = validateComponentProps(propDefs, passedProps);
+      
+      expect(result.valid).toBe(true);
+      expect(result.props.enabled).toBe(true);
+    });
+
+    test('select prop with valid option', () => {
+      const propDefs: Record<string, PropDefinition> = {
+        variant: {
+          type: 'select',
+          default: 'primary',
+          options: ['primary', 'secondary', 'tertiary'],
+        },
+      };
+      const passedProps = { variant: 'secondary' };
+      
+      const result = validateComponentProps(propDefs, passedProps);
+      
+      expect(result.valid).toBe(true);
+      expect(result.props.variant).toBe('secondary');
+    });
+  });
+
+  describe('Invalid types are caught', () => {
+    test('string prop with number value (coerced to string)', () => {
+      const propDefs: Record<string, PropDefinition> = {
+        title: { type: 'string', default: 'Hello' },
+      };
+      const passedProps = { title: 123 };
+      
+      const result = validateComponentProps(propDefs, passedProps);
+      
+      // Coercion makes this valid (123 -> "123")
+      expect(result.valid).toBe(true);
+      expect(result.props.title).toBe('123');
+      expect(typeof result.props.title).toBe('string');
+    });
+
+    test('number prop with string value (non-numeric)', () => {
+      const propDefs: Record<string, PropDefinition> = {
+        count: { type: 'number', default: 0 },
+      };
+      const passedProps = { count: 'not-a-number' };
+      
+      const result = validateComponentProps(propDefs, passedProps);
+      
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+      // Should fall back to default
+      expect(result.props.count).toBe(0);
+    });
+
+    test('select prop with invalid option', () => {
+      const propDefs: Record<string, PropDefinition> = {
+        variant: {
+          type: 'select',
+          default: 'primary',
+          options: ['primary', 'secondary'],
+        },
+      };
+      const passedProps = { variant: 'invalid' };
+      
+      const result = validateComponentProps(propDefs, passedProps);
+      
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+      expect(result.errors[0].message).toContain('not in allowed options');
+      // Should fall back to default
+      expect(result.props.variant).toBe('primary');
+    });
+  });
+
+  describe('Type coercion works correctly', () => {
+    test('coerces string number to number', () => {
+      const propDefs: Record<string, PropDefinition> = {
+        count: { type: 'number', default: 0 },
+      };
+      const passedProps = { count: '123' };
+      
+      const result = validateComponentProps(propDefs, passedProps);
+      
+      expect(result.valid).toBe(true);
+      expect(result.props.count).toBe(123);
+      expect(typeof result.props.count).toBe('number');
+    });
+
+    test('coerces string boolean to boolean', () => {
+      const propDefs: Record<string, PropDefinition> = {
+        enabled: { type: 'boolean', default: false },
+      };
+      const passedProps = { enabled: 'true' };
+      
+      const result = validateComponentProps(propDefs, passedProps);
+      
+      expect(result.valid).toBe(true);
+      expect(result.props.enabled).toBe(true);
+      expect(typeof result.props.enabled).toBe('boolean');
+    });
+  });
+
+  describe('Backward compatibility maintained', () => {
+    test('unknown props allowed but logged', () => {
+      const propDefs: Record<string, PropDefinition> = {
+        title: { type: 'string', default: 'Hello' },
+      };
+      const passedProps = {
+        title: 'World',
+        unknownProp: 'allowed',
+        anotherUnknown: 123,
+      };
+      
+      const result = validateComponentProps(propDefs, passedProps);
+      
+      // Should be valid (unknown props don't fail validation)
+      expect(result.valid).toBe(true);
+      // Unknown props should be preserved
+      expect(result.props.unknownProp).toBe('allowed');
+      expect(result.props.anotherUnknown).toBe(123);
+    });
+
+    test('missing props use defaults', () => {
+      const propDefs: Record<string, PropDefinition> = {
+        title: { type: 'string', default: 'Hello' },
+        count: { type: 'number', default: 42 },
+      };
+      const passedProps = {};
+      
+      const result = validateComponentProps(propDefs, passedProps);
+      
+      expect(result.valid).toBe(true);
+      expect(result.props.title).toBe('Hello');
+      expect(result.props.count).toBe(42);
+    });
+  });
+});
+
+