@zseven-w/pen-core 0.6.0 → 0.7.0

package/src/__tests__/text-measure.test.ts

@@ -1,5 +1,5 @@
-import { describe, it, expect } from 'vitest'
-import type { PenNode } from '@zseven-w/pen-types'
+import { describe, it, expect } from 'vitest';
+import type { PenNode } from '@zseven-w/pen-types';
 import {
   parseSizing,
   defaultLineHeight,
@@ -11,137 +11,142 @@ import {
   resolveTextContent,
   countExplicitTextLines,
   estimateTextHeight,
-} from '../layout/text-measure'
+} from '../layout/text-measure';
 
 describe('text-measure', () => {
   describe('parseSizing', () => {
     it('returns number for number input', () => {
-      expect(parseSizing(100)).toBe(100)
-    })
+      expect(parseSizing(100)).toBe(100);
+    });
 
     it('returns "fill" for fill_container', () => {
-      expect(parseSizing('fill_container')).toBe('fill')
-    })
+      expect(parseSizing('fill_container')).toBe('fill');
+    });
 
     it('returns "fit" for fit_content', () => {
-      expect(parseSizing('fit_content')).toBe('fit')
-    })
+      expect(parseSizing('fit_content')).toBe('fit');
+    });
+
+    it('uses numeric hints from fit_content(N)', () => {
+      expect(parseSizing('fit_content(600)')).toBe(600);
+    });
 
     it('parses numeric strings', () => {
-      expect(parseSizing('200')).toBe(200)
-    })
+      expect(parseSizing('200')).toBe(200);
+    });
 
     it('returns 0 for non-parseable', () => {
-      expect(parseSizing(undefined)).toBe(0)
-      expect(parseSizing('abc')).toBe(0)
-    })
-  })
+      expect(parseSizing(undefined)).toBe(0);
+      expect(parseSizing('abc')).toBe(0);
+    });
+  });
 
   describe('defaultLineHeight', () => {
     it('returns tight leading for display text', () => {
-      expect(defaultLineHeight(48)).toBe(1.0)
-    })
+      expect(defaultLineHeight(48)).toBe(1.0);
+    });
 
     it('returns comfortable leading for body text', () => {
-      expect(defaultLineHeight(14)).toBe(1.5)
-    })
-  })
+      expect(defaultLineHeight(14)).toBe(1.5);
+    });
+  });
 
   describe('CJK detection', () => {
     it('detects CJK code points', () => {
-      expect(isCjkCodePoint('中'.codePointAt(0)!)).toBe(true)
-      expect(isCjkCodePoint('あ'.codePointAt(0)!)).toBe(true)
-      expect(isCjkCodePoint('A'.codePointAt(0)!)).toBe(false)
-    })
+      expect(isCjkCodePoint('中'.codePointAt(0)!)).toBe(true);
+      expect(isCjkCodePoint('あ'.codePointAt(0)!)).toBe(true);
+      expect(isCjkCodePoint('A'.codePointAt(0)!)).toBe(false);
+    });
 
     it('hasCjkText detects CJK in strings', () => {
-      expect(hasCjkText('Hello 世界')).toBe(true)
-      expect(hasCjkText('Hello World')).toBe(false)
-    })
-  })
+      expect(hasCjkText('Hello 世界')).toBe(true);
+      expect(hasCjkText('Hello World')).toBe(false);
+    });
+  });
 
   describe('estimateGlyphWidth', () => {
     it('returns 0 for newline', () => {
-      expect(estimateGlyphWidth('\n', 16)).toBe(0)
-    })
+      expect(estimateGlyphWidth('\n', 16)).toBe(0);
+    });
 
     it('estimates CJK wider than Latin', () => {
-      const cjk = estimateGlyphWidth('中', 16)
-      const latin = estimateGlyphWidth('a', 16)
-      expect(cjk).toBeGreaterThan(latin)
-    })
+      const cjk = estimateGlyphWidth('中', 16);
+      const latin = estimateGlyphWidth('a', 16);
+      expect(cjk).toBeGreaterThan(latin);
+    });
 
     it('estimates uppercase wider than lowercase', () => {
-      const upper = estimateGlyphWidth('A', 16)
-      const lower = estimateGlyphWidth('a', 16)
-      expect(upper).toBeGreaterThan(lower)
-    })
-  })
+      const upper = estimateGlyphWidth('A', 16);
+      const lower = estimateGlyphWidth('a', 16);
+      expect(upper).toBeGreaterThan(lower);
+    });
+  });
 
   describe('estimateLineWidth', () => {
     it('estimates width of a line', () => {
-      const width = estimateLineWidth('Hello', 16)
-      expect(width).toBeGreaterThan(0)
-    })
+      const width = estimateLineWidth('Hello', 16);
+      expect(width).toBeGreaterThan(0);
+    });
 
     it('adds letter spacing', () => {
-      const base = estimateLineWidth('AB', 16, 0)
-      const spaced = estimateLineWidth('AB', 16, 5)
-      expect(spaced).toBeGreaterThan(base)
-    })
-  })
+      const base = estimateLineWidth('AB', 16, 0);
+      const spaced = estimateLineWidth('AB', 16, 5);
+      expect(spaced).toBeGreaterThan(base);
+    });
+  });
 
   describe('estimateTextWidth', () => {
     it('returns the widest line', () => {
-      const width = estimateTextWidth('short\nmuch longer line', 16)
-      const singleWidth = estimateTextWidth('much longer line', 16)
+      const width = estimateTextWidth('short\nmuch longer line', 16);
+      const singleWidth = estimateTextWidth('much longer line', 16);
       // Multi-line should return width of longest line
-      expect(width).toBeCloseTo(singleWidth, 0)
-    })
-  })
+      expect(width).toBeCloseTo(singleWidth, 0);
+    });
+  });
 
   describe('resolveTextContent', () => {
     it('resolves string content', () => {
-      const node: PenNode = { id: '1', type: 'text', content: 'Hello' }
-      expect(resolveTextContent(node)).toBe('Hello')
-    })
+      const node: PenNode = { id: '1', type: 'text', content: 'Hello' };
+      expect(resolveTextContent(node)).toBe('Hello');
+    });
 
     it('resolves styled segment content', () => {
       const node: PenNode = {
-        id: '1', type: 'text',
+        id: '1',
+        type: 'text',
         content: [{ text: 'Hello ' }, { text: 'World' }],
-      }
-      expect(resolveTextContent(node)).toBe('Hello World')
-    })
+      };
+      expect(resolveTextContent(node)).toBe('Hello World');
+    });
 
     it('returns empty for non-text nodes', () => {
-      const node: PenNode = { id: '1', type: 'rectangle' }
-      expect(resolveTextContent(node)).toBe('')
-    })
-  })
+      const node: PenNode = { id: '1', type: 'rectangle' };
+      expect(resolveTextContent(node)).toBe('');
+    });
+  });
 
   describe('countExplicitTextLines', () => {
     it('counts newlines', () => {
-      expect(countExplicitTextLines('a\nb\nc')).toBe(3)
-    })
+      expect(countExplicitTextLines('a\nb\nc')).toBe(3);
+    });
 
     it('returns 1 for empty string', () => {
-      expect(countExplicitTextLines('')).toBe(1)
-    })
-  })
+      expect(countExplicitTextLines('')).toBe(1);
+    });
+  });
 
   describe('estimateTextHeight', () => {
     it('estimates height for single-line text', () => {
-      const node: PenNode = { id: '1', type: 'text', content: 'Hello', fontSize: 16 }
-      const height = estimateTextHeight(node)
-      expect(height).toBeGreaterThan(0)
-      expect(height).toBeLessThan(50)
-    })
+      const node: PenNode = { id: '1', type: 'text', content: 'Hello', fontSize: 16 };
+      const height = estimateTextHeight(node);
+      expect(height).toBeGreaterThan(0);
+      expect(height).toBeLessThan(50);
+    });
 
     it('estimates taller for multi-line text', () => {
-      const single: PenNode = { id: '1', type: 'text', content: 'Hello', fontSize: 16 }
-      const multi: PenNode = { id: '2', type: 'text', content: 'Hello\nWorld', fontSize: 16 }
-      expect(estimateTextHeight(multi)).toBeGreaterThan(estimateTextHeight(single))
-    })
-  })
-})
+      const single: PenNode = { id: '1', type: 'text', content: 'Hello', fontSize: 16 };
+      const multi: PenNode = { id: '2', type: 'text', content: 'Hello\nWorld', fontSize: 16 };
+      expect(estimateTextHeight(multi)).toBeGreaterThan(estimateTextHeight(single));
+    });
+  });
+});

package/src/__tests__/tree-utils.test.ts

@@ -1,5 +1,5 @@
-import { describe, it, expect } from 'vitest'
-import type { PenNode, PenDocument } from '@zseven-w/pen-types'
+import { describe, it, expect } from 'vitest';
+import type { PenNode, PenDocument } from '@zseven-w/pen-types';
 import {
   createEmptyDocument,
   findNodeInTree,
@@ -14,157 +14,188 @@ import {
   migrateToPages,
   DEFAULT_FRAME_ID,
   DEFAULT_PAGE_ID,
-} from '../tree-utils'
+} from '../tree-utils';
 
 const frame = (id: string, children: PenNode[] = []): PenNode => ({
-  id, type: 'frame', name: id, x: 0, y: 0, width: 100, height: 100,
-  fill: [{ type: 'solid', color: '#fff' }], children,
-})
+  id,
+  type: 'frame',
+  name: id,
+  x: 0,
+  y: 0,
+  width: 100,
+  height: 100,
+  fill: [{ type: 'solid', color: '#fff' }],
+  children,
+});
 
 const rect = (id: string): PenNode => ({
-  id, type: 'rectangle', x: 0, y: 0, width: 50, height: 50,
-})
+  id,
+  type: 'rectangle',
+  x: 0,
+  y: 0,
+  width: 50,
+  height: 50,
+});
 
 describe('tree-utils', () => {
   describe('createEmptyDocument', () => {
     it('creates a document with a default page and root frame', () => {
-      const doc = createEmptyDocument()
-      expect(doc.version).toBe('1.0.0')
-      expect(doc.pages).toHaveLength(1)
-      expect(doc.pages![0].id).toBe(DEFAULT_PAGE_ID)
-      expect(doc.pages![0].children).toHaveLength(1)
-      expect(doc.pages![0].children[0].id).toBe(DEFAULT_FRAME_ID)
-    })
-  })
+      const doc = createEmptyDocument();
+      expect(doc.version).toBe('1.0.0');
+      expect(doc.pages).toHaveLength(1);
+      expect(doc.pages![0].id).toBe(DEFAULT_PAGE_ID);
+      expect(doc.pages![0].children).toHaveLength(1);
+      expect(doc.pages![0].children[0].id).toBe(DEFAULT_FRAME_ID);
+    });
+  });
 
   describe('findNodeInTree', () => {
     it('finds a node by id at root level', () => {
-      const nodes = [rect('a'), rect('b')]
-      expect(findNodeInTree(nodes, 'b')?.id).toBe('b')
-    })
+      const nodes = [rect('a'), rect('b')];
+      expect(findNodeInTree(nodes, 'b')?.id).toBe('b');
+    });
 
     it('finds a nested node', () => {
-      const nodes = [frame('parent', [rect('child')])]
-      expect(findNodeInTree(nodes, 'child')?.id).toBe('child')
-    })
+      const nodes = [frame('parent', [rect('child')])];
+      expect(findNodeInTree(nodes, 'child')?.id).toBe('child');
+    });
 
     it('returns undefined for missing node', () => {
-      expect(findNodeInTree([rect('a')], 'missing')).toBeUndefined()
-    })
-  })
+      expect(findNodeInTree([rect('a')], 'missing')).toBeUndefined();
+    });
+  });
 
   describe('findParentInTree', () => {
     it('finds the parent of a child node', () => {
-      const nodes = [frame('parent', [rect('child')])]
-      expect(findParentInTree(nodes, 'child')?.id).toBe('parent')
-    })
+      const nodes = [frame('parent', [rect('child')])];
+      expect(findParentInTree(nodes, 'child')?.id).toBe('parent');
+    });
 
     it('returns undefined for root nodes', () => {
-      expect(findParentInTree([rect('root')], 'root')).toBeUndefined()
-    })
-  })
+      expect(findParentInTree([rect('root')], 'root')).toBeUndefined();
+    });
+  });
 
   describe('removeNodeFromTree', () => {
     it('removes a root node', () => {
-      const result = removeNodeFromTree([rect('a'), rect('b')], 'a')
-      expect(result).toHaveLength(1)
-      expect(result[0].id).toBe('b')
-    })
+      const result = removeNodeFromTree([rect('a'), rect('b')], 'a');
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('b');
+    });
 
     it('removes a nested node', () => {
-      const nodes = [frame('parent', [rect('child1'), rect('child2')])]
-      const result = removeNodeFromTree(nodes, 'child1')
-      const parent = result[0] as PenNode & { children: PenNode[] }
-      expect(parent.children).toHaveLength(1)
-      expect(parent.children[0].id).toBe('child2')
-    })
-  })
+      const nodes = [frame('parent', [rect('child1'), rect('child2')])];
+      const result = removeNodeFromTree(nodes, 'child1');
+      const parent = result[0] as PenNode & { children: PenNode[] };
+      expect(parent.children).toHaveLength(1);
+      expect(parent.children[0].id).toBe('child2');
+    });
+  });
 
   describe('updateNodeInTree', () => {
     it('updates a node by id', () => {
-      const nodes = [rect('a')]
-      const result = updateNodeInTree(nodes, 'a', { name: 'updated' })
-      expect(result[0].name).toBe('updated')
-    })
+      const nodes = [rect('a')];
+      const result = updateNodeInTree(nodes, 'a', { name: 'updated' });
+      expect(result[0].name).toBe('updated');
+    });
 
     it('updates a nested node', () => {
-      const nodes = [frame('parent', [rect('child')])]
-      const result = updateNodeInTree(nodes, 'child', { name: 'updated' })
-      const parent = result[0] as PenNode & { children: PenNode[] }
-      expect(parent.children[0].name).toBe('updated')
-    })
-  })
+      const nodes = [frame('parent', [rect('child')])];
+      const result = updateNodeInTree(nodes, 'child', { name: 'updated' });
+      const parent = result[0] as PenNode & { children: PenNode[] };
+      expect(parent.children[0].name).toBe('updated');
+    });
+
+    it('reuses untouched branches when updating a nested node', () => {
+      const sibling = frame('sibling', [rect('sibling-child')]);
+      const parent = frame('parent', [rect('child')]);
+      const nodes = [parent, sibling];
+
+      const result = updateNodeInTree(nodes, 'child', { name: 'updated' });
+
+      expect(result).not.toBe(nodes);
+      expect(result[0]).not.toBe(parent);
+      expect((result[0] as PenNode & { children: PenNode[] }).children[0].name).toBe('updated');
+      expect(result[1]).toBe(sibling);
+    });
+
+    it('returns the original tree for no-op updates', () => {
+      const nodes = [rect('a')];
+      const result = updateNodeInTree(nodes, 'a', { x: 0 });
+      expect(result).toBe(nodes);
+    });
+  });
 
   describe('flattenNodes', () => {
     it('flattens a nested tree', () => {
-      const nodes = [frame('a', [rect('b'), frame('c', [rect('d')])])]
-      const flat = flattenNodes(nodes)
-      expect(flat.map(n => n.id)).toEqual(['a', 'b', 'c', 'd'])
-    })
-  })
+      const nodes = [frame('a', [rect('b'), frame('c', [rect('d')])])];
+      const flat = flattenNodes(nodes);
+      expect(flat.map((n) => n.id)).toEqual(['a', 'b', 'c', 'd']);
+    });
+  });
 
   describe('insertNodeInTree', () => {
     it('inserts at root level', () => {
-      const result = insertNodeInTree([rect('a')], null, rect('b'))
-      expect(result).toHaveLength(2)
-      expect(result[1].id).toBe('b')
-    })
+      const result = insertNodeInTree([rect('a')], null, rect('b'));
+      expect(result).toHaveLength(2);
+      expect(result[1].id).toBe('b');
+    });
 
     it('inserts into a parent', () => {
-      const nodes = [frame('parent', [rect('existing')])]
-      const result = insertNodeInTree(nodes, 'parent', rect('new'))
-      const parent = result[0] as PenNode & { children: PenNode[] }
-      expect(parent.children).toHaveLength(2)
-      expect(parent.children[1].id).toBe('new')
-    })
+      const nodes = [frame('parent', [rect('existing')])];
+      const result = insertNodeInTree(nodes, 'parent', rect('new'));
+      const parent = result[0] as PenNode & { children: PenNode[] };
+      expect(parent.children).toHaveLength(2);
+      expect(parent.children[1].id).toBe('new');
+    });
 
     it('inserts at a specific index', () => {
-      const nodes = [frame('parent', [rect('a'), rect('c')])]
-      const result = insertNodeInTree(nodes, 'parent', rect('b'), 1)
-      const parent = result[0] as PenNode & { children: PenNode[] }
-      expect(parent.children.map(n => n.id)).toEqual(['a', 'b', 'c'])
-    })
-  })
+      const nodes = [frame('parent', [rect('a'), rect('c')])];
+      const result = insertNodeInTree(nodes, 'parent', rect('b'), 1);
+      const parent = result[0] as PenNode & { children: PenNode[] };
+      expect(parent.children.map((n) => n.id)).toEqual(['a', 'b', 'c']);
+    });
+  });
 
   describe('isDescendantOf', () => {
     it('returns true for a descendant', () => {
-      const nodes = [frame('a', [frame('b', [rect('c')])])]
-      expect(isDescendantOf(nodes, 'c', 'a')).toBe(true)
-    })
+      const nodes = [frame('a', [frame('b', [rect('c')])])];
+      expect(isDescendantOf(nodes, 'c', 'a')).toBe(true);
+    });
 
     it('returns false for non-descendant', () => {
-      const nodes = [frame('a', [rect('b')]), rect('c')]
-      expect(isDescendantOf(nodes, 'c', 'a')).toBe(false)
-    })
-  })
+      const nodes = [frame('a', [rect('b')]), rect('c')];
+      expect(isDescendantOf(nodes, 'c', 'a')).toBe(false);
+    });
+  });
 
   describe('page helpers', () => {
     it('getActivePageChildren returns page children', () => {
-      const doc = createEmptyDocument()
-      const children = getActivePageChildren(doc, DEFAULT_PAGE_ID)
-      expect(children).toHaveLength(1)
-      expect(children[0].id).toBe(DEFAULT_FRAME_ID)
-    })
+      const doc = createEmptyDocument();
+      const children = getActivePageChildren(doc, DEFAULT_PAGE_ID);
+      expect(children).toHaveLength(1);
+      expect(children[0].id).toBe(DEFAULT_FRAME_ID);
+    });
 
     it('setActivePageChildren replaces page children', () => {
-      const doc = createEmptyDocument()
-      const newChildren = [rect('new')]
-      const updated = setActivePageChildren(doc, DEFAULT_PAGE_ID, newChildren)
-      expect(updated.pages![0].children).toHaveLength(1)
-      expect(updated.pages![0].children[0].id).toBe('new')
-    })
+      const doc = createEmptyDocument();
+      const newChildren = [rect('new')];
+      const updated = setActivePageChildren(doc, DEFAULT_PAGE_ID, newChildren);
+      expect(updated.pages![0].children).toHaveLength(1);
+      expect(updated.pages![0].children[0].id).toBe('new');
+    });
 
     it('migrateToPages wraps legacy doc', () => {
-      const legacy: PenDocument = { version: '1.0.0', children: [rect('a')] }
-      const migrated = migrateToPages(legacy)
-      expect(migrated.pages).toHaveLength(1)
-      expect(migrated.pages![0].children[0].id).toBe('a')
-      expect(migrated.children).toEqual([])
-    })
+      const legacy: PenDocument = { version: '1.0.0', children: [rect('a')] };
+      const migrated = migrateToPages(legacy);
+      expect(migrated.pages).toHaveLength(1);
+      expect(migrated.pages![0].children[0].id).toBe('a');
+      expect(migrated.children).toEqual([]);
+    });
 
     it('migrateToPages preserves existing pages', () => {
-      const doc = createEmptyDocument()
-      expect(migrateToPages(doc)).toBe(doc)
-    })
-  })
-})
+      const doc = createEmptyDocument();
+      expect(migrateToPages(doc)).toBe(doc);
+    });
+  });
+});