test: cover corner cases

Signed-off-by: Andres Correa Casablanca <castarco@coderspirit.xyz>

Author: castarco

.eslintrc.cjs

@@ -6,7 +6,7 @@ module.exports = {
 	},
 	parser: '@typescript-eslint/parser',
 	parserOptions: {
-    ecmaVersion: 2022,
+    ecmaVersion: 2020,
 		sourceType: 'module',
     tsConfigRootDir: __dirname,
     project: ['./tsconfig.json'],

src/core.ts

@@ -1,18 +1,18 @@
 export type TreeChild<T extends Tree = Tree> = {
 	node: T,
-	edgeData: Record<string, unknown>,
+	edgeData?: Record<string, unknown> | undefined,
 }
 
 export type Node = {
-	data: Record<string, unknown>,
+	data?: Record<string, unknown> | undefined,
 }
 
 export type Tree = Node & {
-	children?: TreeChild[]
+	children?: TreeChild[] | undefined,
 }
 
 export type TreeWithLayout = Node & {
-	children?: Required<TreeChild<TreeWithLayout>>[]
+	children?: Required<TreeChild<TreeWithLayout>>[] | undefined,
 	layout: {
 		plan: { x: number, y: number },
 	}
@@ -35,7 +35,7 @@ const _computeLeftShiftLayout = (tree: Tree, depth: number = 0, layout?: Interna
 		children: tree.children?.map(child => ({
 			edgeData: child.edgeData,
 			node: _computeLeftShiftLayout(child.node, depth + 1, layout),
-		})) ?? [],
+		})),
 		layout: { plan: { x, y: depth } },
 	} satisfies TreeWithLayout
 

src/tests/core.test.ts

@@ -6,7 +6,7 @@ describe('computeLeftShiftLayout', () => {
 		const resultWithoutChildren = computeLeftShiftLayout({
 			data: { v: 42 },
 		})
-		expect(resultWithoutChildren).toMatchObject({
+		expect(resultWithoutChildren).toEqual({
 			data: { v: 42 },
 			layout: { plan: { x: 0, y: 0 } },
 		})
@@ -15,7 +15,7 @@ describe('computeLeftShiftLayout', () => {
 			data: { v: 42 },
 			children: [],
 		})
-		expect(resultWithEmptyChildren).toMatchObject({
+		expect(resultWithEmptyChildren).toEqual({
 			data: { v: 42 },
 			children: [],
 			layout: { plan: { x: 0, y: 0 } },
@@ -33,7 +33,7 @@ describe('computeLeftShiftLayout', () => {
 			],
 		})
 
-		expect(result).toMatchObject({
+		expect(result).toEqual({
 			data: { v: 42 },
 			children: [
 				{
@@ -47,4 +47,205 @@ describe('computeLeftShiftLayout', () => {
 			layout: { plan: { x: 0, y: 0 } },
 		})
 	})
+
+	it('sets x=0,y=0 & x=0,y=1 & x=1,y=1 for tree with two children', () => {
+		const result = computeLeftShiftLayout({
+			data: { v: 42 },
+			children: [
+				{
+					edgeData: {},
+					node: { data: { v: 43 } },
+				},
+				{
+					edgeData: {},
+					node: { data: { v: 44 } },
+				}
+			],
+		})
+
+		expect(result).toEqual({
+			data: { v: 42 },
+			children: [
+				{
+					edgeData: {},
+					node: {
+						data: { v: 43 },
+						layout: { plan: { x: 0, y: 1 } },
+					},
+				},
+				{
+					edgeData: {},
+					node: {
+						data: { v: 44 },
+						layout: { plan: { x: 1, y: 1 } },
+					},
+				}
+			],
+			layout: { plan: { x: 0, y: 0 } },
+		})
+	})
+
+	it('sets x for ((.,.),(.))', () => {
+		const result = computeLeftShiftLayout({
+			data: { v: 42 },
+			children: [
+				{
+					edgeData: {},
+					node: {
+						data: { v: 43 },
+						children: [
+							{
+								edgeData: {},
+								node: { data: { v: 45 } },
+							},
+							{
+								edgeData: {},
+								node: { data: { v: 46 } },
+							},
+						]
+					},
+				},
+				{
+					edgeData: {},
+					node: {
+						data: { v: 44 },
+						children: [
+							{
+								edgeData: {},
+								node: { data: { v: 47 } },
+							},
+						]
+					},
+				}
+			],
+		})
+
+		expect(result).toEqual({
+			data: { v: 42 },
+			children: [
+				{
+					edgeData: {},
+					node: {
+						data: { v: 43 },
+						children: [
+							{
+								edgeData: {},
+								node: {
+									data: { v: 45 },
+									layout: { plan: { x: 0, y: 2 } },
+								},
+							},
+							{
+								edgeData: {},
+								node: {
+									data: { v: 46 },
+									layout: { plan: { x: 1, y: 2 } },
+								},
+							},
+						],
+						layout: { plan: { x: 0, y: 1 } },
+					},
+				},
+				{
+					edgeData: {},
+					node: {
+						data: { v: 44 },
+						children: [
+							{
+								edgeData: {},
+								node: {
+									data: { v: 47 },
+									layout: { plan: { x: 2, y: 2 } },
+								},
+							},
+						],
+						layout: { plan: { x: 1, y: 1 } },
+					},
+				}
+			],
+			layout: { plan: { x: 0, y: 0 } },
+		})
+	})
+
+	it('sets x for ((.),(.,.))', () => {
+		const result = computeLeftShiftLayout({
+			data: { v: 42 },
+			children: [
+				{
+					edgeData: {},
+					node: {
+						data: { v: 43 },
+						children: [
+							{
+								edgeData: {},
+								node: { data: { v: 45 } },
+							}
+						]
+					},
+				},
+				{
+					edgeData: {},
+					node: {
+						data: { v: 44 },
+						children: [
+							{
+								edgeData: {},
+								node: { data: { v: 46 } },
+							},
+							{
+								edgeData: {},
+								node: { data: { v: 47 } },
+							},
+						]
+					},
+				}
+			],
+		})
+
+		expect(result).toEqual({
+			data: { v: 42 },
+			children: [
+				{
+					edgeData: {},
+					node: {
+						data: { v: 43 },
+						children: [
+							{
+								edgeData: {},
+								node: {
+									data: { v: 45 },
+									layout: { plan: { x: 0, y: 2 } },
+								},
+							},
+						],
+						layout: { plan: { x: 0, y: 1 } },
+					},
+				},
+				{
+					edgeData: {},
+					node: {
+						data: { v: 44 },
+						children: [
+							{
+								edgeData: {},
+								node: {
+									data: { v: 46 },
+									layout: { plan: { x: 1, y: 2 } },
+								},
+							},
+							{
+								edgeData: {},
+								node: {
+									data: { v: 47 },
+									layout: { plan: { x: 2, y: 2 } },
+								},
+							},
+						],
+						layout: { plan: { x: 1, y: 1 } },
+					},
+				}
+			],
+			layout: { plan: { x: 0, y: 0 } },
+		})
+	})
 })