add depth check to oneNoteItemUtils

src/oneNoteDataStructures/oneNoteItemUtils.ts

@@ -6,6 +6,9 @@ import { Polyfills } from '../polyfills';
 
 Polyfills.find();
 
+export type notebookOrSectionGroup = Notebook | SectionGroup;
+export type SectionPathElement = notebookOrSectionGroup | Section;
+
 export class OneNoteItemUtils {
 	/**
 	 * Given the id of the OneNoteItem, and a notebook or sectionGroup list, returns
@@ -98,6 +101,38 @@ export class OneNoteItemUtils {
 
 		return ancestry;
 	}
+
+	/**
+	 * Finds the maximum depth of notebooks list, including sections
+	 */
+	static getDepthOfNotebooks(notebooks: Notebook[]): number {
+		if (!notebooks || notebooks.length === 0) {
+			return 0;
+		}
+		return notebooks.map((notebook) => this.getDepthOfParent(notebook)).reduce((d1, d2) => Math.max(d1, d2));
+	}
+
+	/** 
+	 * Finds the maximum depth of SectionGroup or Notebook, 
+	 * includes the number of sections below it 
+	 */
+	private static getDepthOfParent(parent: notebookOrSectionGroup ): number {
+		if (!parent) {
+			return 0;
+		}
+
+		let containsAtLeastOneSection = parent.sections && parent.sections.length > 0;
+		let maxDepth = containsAtLeastOneSection ? 1 : 0;
+
+		if (parent.sectionGroups) {
+			for (let i = 0; i < parent.sectionGroups.length; i++) {
+				maxDepth = Math.max(this.getDepthOfParent(parent.sectionGroups[i]), maxDepth);
+			}
+		}
+
+		// Include the parent itself
+		return maxDepth + 1;
+	}
 }
 
 export * from './oneNoteApiResponseTransformer';

test/oneNoteDataStructures/oneNoteItemUtils.spec.ts

@@ -1,9 +1,93 @@
 import { Notebook } from '../../src/oneNoteDataStructures/notebook';
 import { OneNoteItem } from '../../src/oneNoteDataStructures/oneNoteItem';
-import { OneNoteItemUtils } from '../../src/oneNoteDataStructures/oneNoteItemUtils';
+import { SectionGroup } from '../../src/oneNoteDataStructures/sectionGroup';
+import { OneNoteItemUtils, SectionPathElement } from '../../src/oneNoteDataStructures/oneNoteItemUtils';
 import { Section } from '../../src/oneNoteDataStructures/section';
 
 describe('OneNoteItemUtils', () => {
+	const notebook1: Notebook = {
+		parent: undefined,
+		id: 'notebook1',
+		name: 'Notebook1',
+		expanded: true,
+		sectionGroups: [],
+		sections: [],
+		apiUrl: '',
+		webUrl: '',
+	};
+
+	const notebook2: Notebook = {
+		parent: undefined,
+		id: 'notebook2',
+		name: 'Notebook2',
+		expanded: false,
+		sectionGroups: [],
+		sections: [],
+		apiUrl: '',
+		webUrl: '',
+	};
+
+	const expandedNotebook: Notebook = {
+		parent: undefined,
+		id: 'notebook2',
+		name: 'Notebook2',
+		expanded: false,
+		sectionGroups: [],
+		sections: [],
+		apiUrl: '',
+		webUrl: '',
+	};
+
+	const section1: Section = {
+		parent: undefined,
+		id: 'section1',
+		name: 'Section1',
+		expanded: false,
+		pages: undefined,
+		apiUrl: '',
+	};
+
+	const section2: Section = {
+		parent: undefined,
+		id: 'section1',
+		name: 'Section1',
+		expanded: false,
+		pages: undefined,
+		apiUrl: '',
+	};
+
+	const sectionGroup: SectionGroup = {
+		parent: notebook2,
+		id: 'sg1',
+		name: 'sg1',
+		expanded: false,
+		sectionGroups: [],
+		sections: [],
+		apiUrl: ''
+	};
+
+	const sectionGroupWithTwoSections: SectionGroup = {
+		parent: notebook2,
+		id: 'sg2',
+		name: 'Sg2',
+		expanded: false,
+		sectionGroups: [],
+		sections: [],
+		apiUrl: ''
+	};
+	sectionGroupWithTwoSections.sections.push(section1, section2);		
+
+	const stackedSectionGroup: SectionGroup = {
+		parent: notebook2,
+		id: 'sg3',
+		name: 'sg3',
+		expanded: false,
+		sectionGroups: [],
+		sections: [],
+		apiUrl: ''
+	};
+	stackedSectionGroup.sectionGroups.push(sectionGroup);
+
 	it('find should return the item that matches the predicate if it is found early in the hierarchy', () => {
 		const notebook: Notebook = {
 			parent: undefined,
@@ -217,4 +301,57 @@ describe('OneNoteItemUtils', () => {
 		const ancestry = OneNoteItemUtils.getAncestry(item);
 		expect(ancestry).toEqual([grandparent, parent, item]);
 	});
+
+	it('getDepthOfNotebooks should return a max depth of 1 if there is one notebook with no other children', () => {
+		const depthOfNotebooks = OneNoteItemUtils.getDepthOfNotebooks([notebook1]);
+		expect(depthOfNotebooks).toEqual(1);
+	});
+
+	it('getDepthOfNotebooks should return a max depth of 1 if there are two notebooks with no other children', () => {
+		const depthOfNotebooks = OneNoteItemUtils.getDepthOfNotebooks([notebook1, notebook2]);
+		expect(depthOfNotebooks).toEqual(1);
+	});
+
+	it('getDepthOfNotebooks returns a max depth of 2 when there are two notebooks where one has sections', () => {
+		section1.parent = notebook1;
+		notebook1.sections.push(section1); 
+
+		const depthOfNotebooks = OneNoteItemUtils.getDepthOfNotebooks([notebook1, notebook2]);
+		expect(depthOfNotebooks).toEqual(2);
+	});
+
+	it('getDepthOfNotebook should return a max depth of 2 when there are two notebooks where one has an empty section group', () => {
+		notebook1.sectionGroups.push(sectionGroup);
+
+		const depthOfNotebooks = OneNoteItemUtils.getDepthOfNotebooks([notebook1, notebook2]);
+		expect(depthOfNotebooks).toEqual(2);
+	});
+
+	it('getDepthOfNotebooks returns a max depth of 3 when there are two notebooks where one has a section group with a section', () => {
+		sectionGroup.sections.push(section1);
+		notebook1.sectionGroups.push(sectionGroup);
+
+		const depthOfNotebooks = OneNoteItemUtils.getDepthOfNotebooks([notebook1, notebook2]);
+		expect(depthOfNotebooks).toEqual(3);
+	});
+
+	it('getDepthOfNotebooks returns a max depth of three when there are two notebooks where one has a section group with multiple sections', () => {
+		notebook1.sectionGroups.push(sectionGroupWithTwoSections);
+
+		const depthOfNotebooks = OneNoteItemUtils.getDepthOfNotebooks([notebook1, notebook2]);
+		expect(depthOfNotebooks).toEqual(3);
+	});
+
+	it('getDepthOfNotebooks returns the correct depth when there are two notebooks with a more complicated tree structure', () => {
+		notebook1.sectionGroups.push(sectionGroupWithTwoSections);
+		notebook2.sectionGroups.push(stackedSectionGroup);
+
+		const depthOfNotebooks = OneNoteItemUtils.getDepthOfNotebooks([notebook1, expandedNotebook]);
+		expect(depthOfNotebooks).toEqual(3);
+	});
+
+	it('getDepthOfNotebooks returns a max depth of 0 if it is given an empty array of Notebooks', () => {
+		expect(OneNoteItemUtils.getDepthOfNotebooks([])).toEqual(0);
+	});
+
 });