meno-core 1.0.0

package/lib/shared/treePathUtils.test.ts

@@ -0,0 +1,539 @@
+/**
+ * Tree Path Utils Tests
+ * Tests for tree structure parsing and navigation utilities
+ */
+
+import { test, expect, describe } from 'bun:test';
+import {
+  validateComponentStructure,
+  getRootData,
+  getParentAndIndexFromPath,
+  extractStructureWithoutStyles,
+  calculateInsertionIndex,
+  isValidNodeLocation,
+  isValidPath,
+  isPageDataParent,
+  isComponentNodeParent,
+  getParentChildren,
+  setParentChildren,
+} from './treePathUtils';
+import type { ComponentNode, PageData, JSONPage, PageDataWithComponent } from './types';
+import { NODE_TYPE } from './constants';
+
+// Helper to create a basic page structure
+function createPageData(root?: Partial<ComponentNode>): JSONPage {
+  return {
+    root: {
+      type: NODE_TYPE.NODE,
+      tag: 'div',
+      children: [],
+      ...root,
+    },
+  };
+}
+
+// Helper to create a component page structure
+function createComponentPageData(structure?: Partial<ComponentNode>): PageDataWithComponent {
+  return {
+    component: {
+      interface: {},
+      structure: {
+        type: NODE_TYPE.NODE,
+        tag: 'div',
+        children: [],
+        ...structure,
+      },
+    },
+  };
+}
+
+// Helper to create a node
+function createNode(overrides?: Partial<ComponentNode>): ComponentNode {
+  return {
+    type: NODE_TYPE.NODE,
+    tag: 'div',
+    children: [],
+    ...overrides,
+  } as ComponentNode;
+}
+
+describe('validateComponentStructure', () => {
+  test('should return true for valid page with root', () => {
+    const pageData = createPageData();
+    expect(validateComponentStructure(pageData)).toBe(true);
+  });
+
+  test('should return true for valid component with structure', () => {
+    const pageData = createComponentPageData();
+    expect(validateComponentStructure(pageData)).toBe(true);
+  });
+
+  test('should return false for null', () => {
+    expect(validateComponentStructure(null)).toBe(false);
+  });
+
+  test('should return false for empty object', () => {
+    expect(validateComponentStructure({} as PageData)).toBe(false);
+  });
+
+  test('should return false for component without structure', () => {
+    const pageData = { component: {} } as PageDataWithComponent;
+    expect(validateComponentStructure(pageData)).toBe(false);
+  });
+});
+
+describe('getRootData', () => {
+  test('should return root for page format', () => {
+    const pageData = createPageData({ tag: 'main' });
+    const root = getRootData(pageData);
+    expect(root?.tag).toBe('main');
+  });
+
+  test('should return structure for component format', () => {
+    const pageData = createComponentPageData({ tag: 'section' });
+    const root = getRootData(pageData);
+    expect(root?.tag).toBe('section');
+  });
+
+  test('should return null for null input', () => {
+    expect(getRootData(null)).toBeNull();
+  });
+
+  test('should return null for empty object', () => {
+    expect(getRootData({} as PageData)).toBeNull();
+  });
+
+  test('should return null for component with missing structure', () => {
+    const pageData = { component: {} } as PageDataWithComponent;
+    expect(getRootData(pageData)).toBeNull();
+  });
+});
+
+describe('getParentAndIndexFromPath', () => {
+  test('should return root for path [0]', () => {
+    const pageData = createPageData({ tag: 'main' });
+    const result = getParentAndIndexFromPath([0], pageData);
+
+    expect(result).not.toBeNull();
+    expect(result?.node?.tag).toBe('main');
+    expect(result?.index).toBe(0);
+    expect(result?.parent).toBe(pageData);
+  });
+
+  test('should return child for path [0, 0]', () => {
+    const child = createNode({ tag: 'p' });
+    const pageData = createPageData({ children: [child] });
+    const result = getParentAndIndexFromPath([0, 0], pageData);
+
+    expect(result).not.toBeNull();
+    expect(result?.node?.tag).toBe('p');
+    expect(result?.index).toBe(0);
+  });
+
+  test('should return deeply nested child', () => {
+    const deepChild = createNode({ tag: 'span' });
+    const pageData = createPageData({
+      children: [
+        createNode({
+          tag: 'section',
+          children: [
+            createNode({
+              tag: 'article',
+              children: [deepChild],
+            }),
+          ],
+        }),
+      ],
+    });
+    const result = getParentAndIndexFromPath([0, 0, 0, 0], pageData);
+
+    expect(result).not.toBeNull();
+    expect(result?.node?.tag).toBe('span');
+  });
+
+  test('should return null for invalid path', () => {
+    const pageData = createPageData();
+    const result = getParentAndIndexFromPath([0, 99], pageData);
+
+    expect(result).toBeNull();
+  });
+
+  test('should return null for empty children', () => {
+    const pageData = createPageData({ children: [] });
+    const result = getParentAndIndexFromPath([0, 0], pageData);
+
+    expect(result).toBeNull();
+  });
+
+  test('should return null for string child at path', () => {
+    const pageData = createPageData({ children: ['text content'] });
+    const result = getParentAndIndexFromPath([0, 0], pageData);
+
+    expect(result).toBeNull();
+  });
+
+  test('should handle string path conversion', () => {
+    const child = createNode({ tag: 'p' });
+    const pageData = createPageData({ children: [child] });
+    // stringToPath expects comma-separated format: "0,0" -> [0, 0]
+    const result = getParentAndIndexFromPath('0,0', pageData);
+
+    // Should successfully convert string to path and find the node
+    expect(result).not.toBeNull();
+    expect(result?.node?.tag).toBe('p');
+  });
+
+  test('should return correct parent for nested path', () => {
+    const grandchild = createNode({ tag: 'span' });
+    const child = createNode({ tag: 'p', children: [grandchild] });
+    const pageData = createPageData({ children: [child] });
+    const result = getParentAndIndexFromPath([0, 0, 0], pageData);
+
+    expect(result).not.toBeNull();
+    expect(result?.node?.tag).toBe('span');
+    expect((result?.parent as ComponentNode)?.tag).toBe('p');
+  });
+});
+
+describe('extractStructureWithoutStyles', () => {
+  test('should preserve type and tag', () => {
+    const node = createNode({ tag: 'div', style: { base: { color: 'red' } } });
+    const result = extractStructureWithoutStyles(node) as ComponentNode;
+
+    expect(result.type).toBe(NODE_TYPE.NODE);
+    expect(result.tag).toBe('div');
+  });
+
+  test('should remove style property', () => {
+    const node = createNode({ tag: 'div', style: { base: { color: 'red' } } });
+    const result = extractStructureWithoutStyles(node) as ComponentNode;
+
+    expect((result as any).style).toBeUndefined();
+  });
+
+  test('should preserve children structure', () => {
+    const node = createNode({
+      tag: 'div',
+      children: [createNode({ tag: 'p' })],
+    });
+    const result = extractStructureWithoutStyles(node) as ComponentNode;
+
+    expect(result.children?.length).toBe(1);
+    expect((result.children?.[0] as ComponentNode)?.tag).toBe('p');
+  });
+
+  test('should handle string children', () => {
+    const node = createNode({ tag: 'p', children: ['text'] });
+    const result = extractStructureWithoutStyles(node) as ComponentNode;
+
+    expect(result.children).toEqual(['text']);
+  });
+
+  test('should return null for null input', () => {
+    expect(extractStructureWithoutStyles(null)).toBeNull();
+  });
+
+  test('should return undefined for undefined input', () => {
+    expect(extractStructureWithoutStyles(undefined)).toBeUndefined();
+  });
+
+  test('should return string for string input', () => {
+    expect(extractStructureWithoutStyles('text')).toBe('text');
+  });
+});
+
+describe('calculateInsertionIndex', () => {
+  const mockChildren = [
+    createNode({ tag: 'p' }),
+    createNode({ tag: 'span' }),
+    createNode({ tag: 'div' }),
+  ];
+  const emptyNodeDataMap = new Map<string, ComponentNode | string>();
+
+  test('should use childIndex when provided', () => {
+    const target = { childIndex: 1 };
+    expect(calculateInsertionIndex(target, mockChildren, emptyNodeDataMap)).toBe(1);
+  });
+
+  test('should clamp childIndex to array length', () => {
+    const target = { childIndex: 99 };
+    expect(calculateInsertionIndex(target, mockChildren, emptyNodeDataMap)).toBe(3);
+  });
+
+  test('should handle negative childIndex (implementation returns array length)', () => {
+    // Note: Implementation uses childIndex >= 0 check, so negative values fall through
+    // to append behavior (returns array length)
+    const target = { childIndex: -5 };
+    // Actual behavior: negative index fails the >= 0 check, falls through to append
+    expect(calculateInsertionIndex(target, mockChildren, emptyNodeDataMap)).toBe(3);
+  });
+
+  test('should use linearIndex as fallback', () => {
+    const target = { linearIndex: 2 };
+    expect(calculateInsertionIndex(target, mockChildren, emptyNodeDataMap)).toBe(2);
+  });
+
+  test('should return array length when no index provided', () => {
+    const target = {};
+    expect(calculateInsertionIndex(target, mockChildren, emptyNodeDataMap)).toBe(3);
+  });
+
+  test('should handle childAfterItem with nodeDataMap', () => {
+    const nodeDataMap = new Map<string, ComponentNode | string>();
+    nodeDataMap.set('path_0', mockChildren[0]);
+
+    const target = { childAfterItem: { index: 'path_0' } };
+    expect(calculateInsertionIndex(target, mockChildren, nodeDataMap)).toBe(1);
+  });
+
+  test('should handle childBeforeItem with nodeDataMap', () => {
+    const nodeDataMap = new Map<string, ComponentNode | string>();
+    nodeDataMap.set('path_1', mockChildren[1]);
+
+    const target = { childBeforeItem: { index: 'path_1' } };
+    expect(calculateInsertionIndex(target, mockChildren, nodeDataMap)).toBe(1);
+  });
+});
+
+describe('isValidNodeLocation', () => {
+  test('should return true for valid NodeLocation', () => {
+    const location = {
+      parent: createNode(),
+      index: 0,
+      node: createNode(),
+    };
+    expect(isValidNodeLocation(location)).toBe(true);
+  });
+
+  test('should return true for NodeLocation with null node', () => {
+    const location = {
+      parent: createNode(),
+      index: 0,
+      node: null,
+    };
+    expect(isValidNodeLocation(location)).toBe(true);
+  });
+
+  test('should return true for NodeLocation with null parent', () => {
+    const location = {
+      parent: null,
+      index: 0,
+      node: createNode(),
+    };
+    expect(isValidNodeLocation(location)).toBe(true);
+  });
+
+  test('should return false for null', () => {
+    expect(isValidNodeLocation(null)).toBe(false);
+  });
+
+  test('should return false for missing index', () => {
+    const location = { parent: createNode(), node: createNode() };
+    expect(isValidNodeLocation(location)).toBe(false);
+  });
+
+  test('should return false for negative index', () => {
+    const location = { parent: createNode(), index: -1, node: createNode() };
+    expect(isValidNodeLocation(location)).toBe(false);
+  });
+});
+
+describe('isValidPath', () => {
+  test('should return true for valid path array', () => {
+    expect(isValidPath([0])).toBe(true);
+    expect(isValidPath([0, 1, 2])).toBe(true);
+  });
+
+  test('should return true for empty array', () => {
+    expect(isValidPath([])).toBe(true);
+  });
+
+  test('should return false for non-array', () => {
+    expect(isValidPath('0,1,2')).toBe(false);
+    expect(isValidPath(null)).toBe(false);
+    expect(isValidPath(undefined)).toBe(false);
+  });
+
+  test('should return false for array with non-numbers', () => {
+    expect(isValidPath([0, 'a', 2])).toBe(false);
+    expect(isValidPath([null])).toBe(false);
+  });
+
+  test('should return false for array with negative numbers', () => {
+    expect(isValidPath([0, -1, 2])).toBe(false);
+  });
+});
+
+describe('isPageDataParent', () => {
+  test('should return true for JSONPage', () => {
+    const pageData = createPageData();
+    expect(isPageDataParent(pageData)).toBe(true);
+  });
+
+  test('should return true for PageDataWithComponent', () => {
+    const pageData = createComponentPageData();
+    expect(isPageDataParent(pageData)).toBe(true);
+  });
+
+  test('should return false for ComponentNode', () => {
+    const node = createNode();
+    expect(isPageDataParent(node)).toBe(false);
+  });
+
+  test('should return false for null', () => {
+    expect(isPageDataParent(null)).toBe(false);
+  });
+});
+
+describe('isComponentNodeParent', () => {
+  test('should return true for HtmlNode', () => {
+    const node = createNode({ tag: 'div' });
+    expect(isComponentNodeParent(node)).toBe(true);
+  });
+
+  test('should return true for ComponentInstanceNode', () => {
+    const node = { type: NODE_TYPE.COMPONENT, component: 'Button' } as ComponentNode;
+    expect(isComponentNodeParent(node)).toBe(true);
+  });
+
+  test('should return true for SlotMarker', () => {
+    const node = { type: NODE_TYPE.SLOT } as ComponentNode;
+    expect(isComponentNodeParent(node)).toBe(true);
+  });
+
+  test('should return true for ObjectLinkNode', () => {
+    const node = { type: NODE_TYPE.OBJECT_LINK } as ComponentNode;
+    expect(isComponentNodeParent(node)).toBe(true);
+  });
+
+  test('should return true for EmbedNode', () => {
+    const node = { type: NODE_TYPE.EMBED } as ComponentNode;
+    expect(isComponentNodeParent(node)).toBe(true);
+  });
+
+  test('should return false for PageData', () => {
+    const pageData = createPageData();
+    expect(isComponentNodeParent(pageData)).toBe(false);
+  });
+
+  test('should return false for null', () => {
+    expect(isComponentNodeParent(null)).toBe(false);
+  });
+});
+
+describe('getParentChildren', () => {
+  test('should return children from ComponentNode', () => {
+    const children = [createNode({ tag: 'p' })];
+    const node = createNode({ children });
+    const result = getParentChildren(node);
+
+    expect(result).toBe(children);
+  });
+
+  test('should return children from PageData root', () => {
+    const children = [createNode({ tag: 'p' })];
+    const pageData = createPageData({ children });
+    const result = getParentChildren(pageData);
+
+    expect(result).toBe(children);
+  });
+
+  test('should return null for node without children', () => {
+    const node = { type: NODE_TYPE.NODE, tag: 'img' } as ComponentNode;
+    const result = getParentChildren(node);
+
+    expect(result).toBeNull();
+  });
+
+  test('should return null for null input', () => {
+    expect(getParentChildren(null)).toBeNull();
+  });
+});
+
+describe('setParentChildren', () => {
+  test('should set children on ComponentNode', () => {
+    const node = createNode({ children: [] });
+    const newChildren = [createNode({ tag: 'p' })];
+
+    setParentChildren(node, newChildren);
+
+    expect(node.children).toBe(newChildren);
+  });
+
+  test('should set children on PageData root', () => {
+    const pageData = createPageData({ children: [] });
+    const newChildren = [createNode({ tag: 'p' })];
+
+    setParentChildren(pageData, newChildren);
+
+    expect(pageData.root?.children).toBe(newChildren);
+  });
+
+  test('should handle null parent gracefully', () => {
+    expect(() => setParentChildren(null, [])).not.toThrow();
+  });
+});
+
+describe('edge cases', () => {
+  test('getParentAndIndexFromPath should handle component pageData format', () => {
+    const child = createNode({ tag: 'span' });
+    const pageData = createComponentPageData({ children: [child] });
+    const result = getParentAndIndexFromPath([0, 0], pageData);
+
+    expect(result).not.toBeNull();
+    expect(result?.node?.tag).toBe('span');
+  });
+
+  test('extractStructureWithoutStyles should handle deeply nested structures', () => {
+    const deepNode = createNode({
+      tag: 'div',
+      style: { base: { color: 'red' } },
+      children: [
+        createNode({
+          tag: 'section',
+          style: { base: { padding: '10px' } },
+          children: [
+            createNode({
+              tag: 'p',
+              style: { base: { fontSize: '16px' } },
+              children: ['text'],
+            }),
+          ],
+        }),
+      ],
+    });
+
+    const result = extractStructureWithoutStyles(deepNode) as ComponentNode;
+
+    // Verify nested structure is preserved
+    expect(result.tag).toBe('div');
+    const section = result.children?.[0] as ComponentNode;
+    expect(section.tag).toBe('section');
+    const p = section.children?.[0] as ComponentNode;
+    expect(p.tag).toBe('p');
+    expect(p.children).toEqual(['text']);
+
+    // Verify no styles remain
+    expect((result as any).style).toBeUndefined();
+    expect((section as any).style).toBeUndefined();
+    expect((p as any).style).toBeUndefined();
+  });
+
+  test('should handle mixed children (nodes and strings)', () => {
+    const pageData = createPageData({
+      children: [
+        'text before',
+        createNode({ tag: 'span' }),
+        'text after',
+      ],
+    });
+
+    // Path to span should work
+    const result = getParentAndIndexFromPath([0, 1], pageData);
+    expect(result?.node?.tag).toBe('span');
+
+    // Path to string should return null
+    const textResult = getParentAndIndexFromPath([0, 0], pageData);
+    expect(textResult).toBeNull();
+  });
+});