@webitel/ui-sdk 26.8.117 → 26.8.118

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webitel/ui-sdk",
-	"version": "26.8.117",
+	"version": "26.8.118",
 	"private": false,
 	"scripts": {
 		"dev": "npm run docs:dev",

package/src/utils/__tests__/findTreePath.spec.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'vitest';
+
+import { findTreePath } from '../findTreePath';
+
+interface Service {
+	id: string;
+	name: string;
+	service?: Service[];
+}
+
+const services: Service[] = [
+	{
+		id: 'billing',
+		name: 'Billing',
+		service: [
+			{
+				id: 'refunds',
+				name: 'Refunds',
+				service: [
+					{
+						id: 'card',
+						name: 'Card refund',
+					},
+				],
+			},
+		],
+	},
+	{
+		id: 'support',
+		name: 'Support',
+	},
+];
+
+const byId = (id: string) => (service: Service) => service.id === id;
+
+describe('findTreePath', () => {
+	it('returns the nodes from the root down to the target', () => {
+		expect(
+			findTreePath(services, byId('card'), 'service')?.map(({ name }) => name),
+		).toEqual([
+			'Billing',
+			'Refunds',
+			'Card refund',
+		]);
+	});
+
+	it('returns a one-node path for a root', () => {
+		expect(findTreePath(services, byId('support'), 'service')).toEqual([
+			services[1],
+		]);
+	});
+
+	it('returns null when nothing matches, or there is no tree', () => {
+		expect(findTreePath(services, byId('missing'), 'service')).toBeNull();
+		expect(findTreePath(undefined, byId('card'), 'service')).toBeNull();
+		expect(findTreePath([], byId('card'), 'service')).toBeNull();
+	});
+
+	it('stops at the first match, depth first', () => {
+		const tree = [
+			{
+				id: 'a',
+				children: [
+					{
+						id: 'x',
+					},
+				],
+			},
+			{
+				id: 'x',
+			},
+		];
+
+		expect(
+			findTreePath(tree, (node) => node.id === 'x', 'children')?.map(
+				({ id }) => id,
+			),
+		).toEqual([
+			'a',
+			'x',
+		]);
+	});
+});

package/src/utils/findTreePath.ts

@@ -0,0 +1,33 @@
+/**
+ * Walks a tree depth-first and returns the nodes from a root down to the
+ * first node matching `isTarget`, both ends included, or `null` when nothing
+ * matches. Children are read from `childrenKey` (e.g. `service` for case
+ * service catalogs, whose services nest under `service`).
+ *
+ * The path is what a breadcrumb, an "A / B / C" label or an ancestor check
+ * needs: `path.map(({ name }) => name)`, `path.slice(0, -1)`, and so on.
+ */
+export function findTreePath<TNode extends object>(
+	nodes: readonly TNode[] | null | undefined,
+	isTarget: (node: TNode) => boolean,
+	// NoInfer: the node type comes from `nodes` only; inferred from the key
+	// literal instead, loosely typed trees narrowed to `{ service: any }`
+	childrenKey: NoInfer<keyof TNode>,
+): TNode[] | null {
+	for (const node of nodes ?? []) {
+		if (isTarget(node))
+			return [
+				node,
+			];
+		const children = node[childrenKey];
+		if (Array.isArray(children)) {
+			const path = findTreePath(children as TNode[], isTarget, childrenKey);
+			if (path)
+				return [
+					node,
+					...path,
+				];
+		}
+	}
+	return null;
+}

package/src/utils/index.ts

@@ -1,3 +1,4 @@
 export * from './displayText';
+export * from './findTreePath';
 export * from './formatDate';
 export * from './prettifyDate';