@salesforce/ui-bundle-template-feature-angular-search 0.0.0-stage → 12.14.0

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/features/search/utils/identifier.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+const IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+/**
+ * Throws unless `name` is a valid GraphQL identifier. Anything interpolated
+ * into a query document must pass this first.
+ */
+export function assertValidIdentifier(name: string, kind: string): void {
+	if (typeof name !== "string" || !IDENTIFIER_PATTERN.test(name)) {
+		throw new Error(
+			`Invalid ${kind} "${name}". Must match /^[A-Za-z_][A-Za-z0-9_]*$/ to be a valid GraphQL identifier.`,
+		);
+	}
+}

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/features/search/utils/merge-utils.spec.ts

@@ -0,0 +1,199 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+	computeMergedPagination,
+	computePerSourcePagination,
+	filterToGlobalPage,
+	mergeNodes,
+	mergedFetchSize,
+	resolvePagination,
+	validatePageSize,
+	windowMergedPage,
+} from "./merge-utils";
+import type { SearchConfig } from "../types/search-config.types";
+
+const sources = [
+	{ key: "a", nodes: ["a1", "a2", "a3", "a4"], weight: 4 },
+	{ key: "b", nodes: ["b1", "b2"], weight: 2 },
+];
+
+const order = (items: { node: unknown }[]) => items.map((i) => i.node);
+
+describe("resolvePagination", () => {
+	const base: SearchConfig = { sources: [] };
+
+	it("applies defaults when pagination is omitted", () => {
+		expect(resolvePagination(base)).toEqual({
+			mode: "per-source",
+			mergeOrder: "sequential",
+			pageSize: 10,
+			pageSizeOptions: [10, 25, 50],
+		});
+	});
+
+	it("uses the configured values", () => {
+		const resolved = resolvePagination({
+			...base,
+			pagination: {
+				mode: "merged",
+				mergeOrder: "proportional",
+				pageSize: 6,
+				pageSizeOptions: [6, 12],
+			},
+		});
+		expect(resolved).toMatchObject({ mode: "merged", mergeOrder: "proportional", pageSize: 6 });
+	});
+
+	it("falls back to the first option when pageSize is missing", () => {
+		const resolved = resolvePagination({
+			...base,
+			pagination: { pageSizeOptions: [5, 10] } as SearchConfig["pagination"],
+		});
+		expect(resolved.pageSize).toBe(5);
+	});
+});
+
+describe("validatePageSize", () => {
+	const pagination = resolvePagination({
+		sources: [],
+		pagination: { pageSize: 10, pageSizeOptions: [10, 25] },
+	});
+
+	it("keeps an allowed size and falls back to the default otherwise", () => {
+		expect(validatePageSize(pagination, 25)).toBe(25);
+		expect(validatePageSize(pagination, 7)).toBe(10);
+	});
+});
+
+describe("mergedFetchSize", () => {
+	it("fetches the whole front-anchored window", () => {
+		expect(mergedFetchSize(0, 6)).toBe(6);
+		expect(mergedFetchSize(2, 6)).toBe(18);
+	});
+});
+
+describe("mergeNodes", () => {
+	it("sequential: source by source in config order", () => {
+		expect(order(mergeNodes(sources, "sequential"))).toEqual(["a1", "a2", "a3", "a4", "b1", "b2"]);
+	});
+
+	it("interleaved: round-robin until the longer source is exhausted", () => {
+		expect(order(mergeNodes(sources, "interleaved"))).toEqual(["a1", "b1", "a2", "b2", "a3", "a4"]);
+	});
+
+	it("proportional: spreads sources by their weight", () => {
+		// keys: a = .125 .375 .625 .875, b = .25 .75
+		expect(order(mergeNodes(sources, "proportional"))).toEqual([
+			"a1",
+			"b1",
+			"a2",
+			"a3",
+			"b2",
+			"a4",
+		]);
+	});
+
+	it("proportional: treats a zero weight as 1 and breaks ties by source order", () => {
+		const merged = mergeNodes(
+			[
+				{ key: "a", nodes: ["a1"], weight: 0 },
+				{ key: "b", nodes: ["b1"], weight: 0 },
+			],
+			"proportional",
+		);
+		expect(order(merged)).toEqual(["a1", "b1"]);
+	});
+
+	it("tags each node with its source key", () => {
+		expect(mergeNodes(sources, "sequential")[4]).toEqual({ sourceKey: "b", node: "b1" });
+	});
+});
+
+describe("merged pagination", () => {
+	it("computes page count and navigation flags", () => {
+		expect(computeMergedPagination(13, 6, 1, [6, 12])).toEqual({
+			pageIndex: 1,
+			pageCount: 3,
+			pageSize: 6,
+			pageSizeOptions: [6, 12],
+			hasNextPage: true,
+			hasPreviousPage: true,
+			totalCount: 13,
+		});
+	});
+
+	it("clamps the page index when the total shrinks", () => {
+		const state = computeMergedPagination(7, 6, 5, [6]);
+		expect(state.pageIndex).toBe(1);
+		expect(state.hasNextPage).toBe(false);
+	});
+
+	it("reports zero pages for no results", () => {
+		expect(computeMergedPagination(0, 6, 3, [6])).toMatchObject({
+			pageIndex: 0,
+			pageCount: 0,
+			hasNextPage: false,
+			hasPreviousPage: false,
+		});
+	});
+
+	it("windows the merged list into a page", () => {
+		const items = mergeNodes(sources, "sequential");
+		expect(order(windowMergedPage(items, 0, 4))).toEqual(["a1", "a2", "a3", "a4"]);
+		expect(order(windowMergedPage(items, 1, 4))).toEqual(["b1", "b2"]);
+	});
+});
+
+describe("per-source pagination", () => {
+	it("uses the furthest source for the page index and the widest span for the count", () => {
+		const state = computePerSourcePagination(
+			[
+				{ key: "a", pageIndex: 1, hasNextPage: true, totalCount: 35, nodeCount: 10 },
+				{ key: "b", pageIndex: 0, hasNextPage: false, totalCount: 4, nodeCount: 4 },
+			],
+			10,
+			[10, 25],
+		);
+
+		expect(state).toMatchObject({
+			pageIndex: 1,
+			pageCount: 4,
+			totalCount: 39,
+			hasNextPage: true,
+			hasPreviousPage: true,
+		});
+	});
+
+	it("estimates a lower bound when totalCount is absent", () => {
+		const state = computePerSourcePagination(
+			[{ key: "a", pageIndex: 1, hasNextPage: true, totalCount: null, nodeCount: 10 }],
+			10,
+			[10],
+		);
+
+		expect(state.pageCount).toBe(3);
+		expect(state.totalCount).toBe(10);
+	});
+
+	it("reports zero pages for no results", () => {
+		const state = computePerSourcePagination(
+			[{ key: "a", pageIndex: 0, hasNextPage: false, totalCount: 0, nodeCount: 0 }],
+			10,
+			[10],
+		);
+
+		expect(state.pageCount).toBe(0);
+	});
+
+	it("drops nodes from sources left behind the global page", () => {
+		const items = mergeNodes(sources, "sequential");
+		const filtered = filterToGlobalPage(items, { a: 1, b: 0 }, 1);
+
+		expect(order(filtered)).toEqual(["a1", "a2", "a3", "a4"]);
+	});
+});

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/features/search/utils/merge-utils.ts

@@ -0,0 +1,177 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/**
+ * Pure pagination/merge logic for multi-source search.
+ *
+ * Merged mode treats the cumulative result set as one list windowed into fixed
+ * pages: every in-scope source fetches its first `(page + 1) * pageSize` rows
+ * (no cursor), the rows are ordered per `mergeOrder`, and the page slice is
+ * taken. Per-source mode keeps independent cursors per source.
+ */
+import { DEFAULT_PAGE_SIZE, DEFAULT_PAGE_SIZE_OPTIONS } from "../constants";
+import type { MergeOrder, PaginationMode, SearchConfig } from "../types/search-config.types";
+import type { GlobalPaginationState, MergedResultItem } from "../types/search-result.types";
+
+export interface ResolvedPagination {
+	mode: PaginationMode;
+	mergeOrder: MergeOrder;
+	pageSize: number;
+	pageSizeOptions: number[];
+}
+
+/** Resolves the single global pagination config, filling in defaults. */
+export function resolvePagination(config: SearchConfig): ResolvedPagination {
+	const p = config.pagination;
+	const pageSizeOptions =
+		p?.pageSizeOptions && p.pageSizeOptions.length > 0
+			? p.pageSizeOptions
+			: DEFAULT_PAGE_SIZE_OPTIONS;
+	return {
+		mode: p?.mode ?? "per-source",
+		mergeOrder: p?.mergeOrder ?? "sequential",
+		pageSize: p?.pageSize ?? pageSizeOptions[0] ?? DEFAULT_PAGE_SIZE,
+		pageSizeOptions,
+	};
+}
+
+/** Clamps a requested size to the configured options. */
+export function validatePageSize(pagination: ResolvedPagination, size: number): number {
+	const valid = pagination.pageSizeOptions;
+	if (valid.length === 0) return size;
+	return valid.includes(size) ? size : pagination.pageSize;
+}
+
+/** Rows each source must fetch (from its front) to compute merged page `pageIndex`. */
+export function mergedFetchSize(pageIndex: number, pageSize: number): number {
+	return (pageIndex + 1) * pageSize;
+}
+
+export interface MergeSourceInput {
+	key: string;
+	nodes: unknown[];
+	/** Proportional weight: the source's true total, else the fetched length. */
+	weight: number;
+}
+
+/**
+ * Flattens every source's fetched nodes into one list ordered per `order`:
+ *   - sequential: all of source 1, then source 2, ... (config order).
+ *   - interleaved: round-robin, one node per source per round.
+ *   - proportional: each node gets key (i + 0.5) / weight; sorting by key
+ *     spreads each source evenly in proportion to its size.
+ */
+export function mergeNodes(sources: MergeSourceInput[], order: MergeOrder): MergedResultItem[] {
+	const out: MergedResultItem[] = [];
+
+	if (order === "interleaved") {
+		const maxLen = sources.reduce((m, l) => Math.max(m, l.nodes.length), 0);
+		for (let round = 0; round < maxLen; round++) {
+			for (const l of sources) {
+				if (round < l.nodes.length) out.push({ sourceKey: l.key, node: l.nodes[round] });
+			}
+		}
+	} else if (order === "proportional") {
+		const tagged = sources.flatMap((l, sIdx) =>
+			l.nodes.map((node, i) => ({
+				sourceKey: l.key,
+				node,
+				sIdx,
+				i,
+				sortKey: (i + 0.5) / (l.weight > 0 ? l.weight : 1),
+			})),
+		);
+		tagged.sort((a, b) => a.sortKey - b.sortKey || a.sIdx - b.sIdx || a.i - b.i);
+		for (const t of tagged) out.push({ sourceKey: t.sourceKey, node: t.node });
+	} else {
+		for (const l of sources) {
+			for (const node of l.nodes) out.push({ sourceKey: l.key, node });
+		}
+	}
+	return out;
+}
+
+/** Merged-mode pagination data; `pageIndex` is clamped if `totalCount` shrank. */
+export function computeMergedPagination(
+	totalCount: number,
+	pageSize: number,
+	requestedPageIndex: number,
+	pageSizeOptions: readonly number[],
+): GlobalPaginationState {
+	const pageCount = totalCount === 0 ? 0 : Math.ceil(totalCount / pageSize);
+	const pageIndex = pageCount === 0 ? 0 : Math.min(requestedPageIndex, pageCount - 1);
+	return {
+		pageIndex,
+		pageCount,
+		pageSize,
+		pageSizeOptions,
+		hasNextPage: pageIndex + 1 < pageCount,
+		hasPreviousPage: pageIndex > 0,
+		totalCount,
+	};
+}
+
+/** The page-`pageIndex` slice of the merged list. */
+export function windowMergedPage(
+	items: MergedResultItem[],
+	pageIndex: number,
+	pageSize: number,
+): MergedResultItem[] {
+	const start = pageIndex * pageSize;
+	return items.slice(start, start + pageSize);
+}
+
+export interface PerSourcePageInput {
+	key: string;
+	pageIndex: number;
+	hasNextPage: boolean;
+	totalCount: number | null;
+	nodeCount: number;
+}
+
+/**
+ * Per-source mode: a "global page" is the furthest-advanced in-scope source's
+ * page. `pageCount` is the max pages any source spans (from `totalCount`, else
+ * a lower bound from its own position).
+ */
+export function computePerSourcePagination(
+	sources: PerSourcePageInput[],
+	pageSize: number,
+	pageSizeOptions: readonly number[],
+): GlobalPaginationState {
+	const pageIndex = sources.reduce((max, c) => Math.max(max, c.pageIndex), 0);
+	const totalCount = sources.reduce((sum, c) => sum + (c.totalCount ?? c.nodeCount), 0);
+
+	const pageCount = sources.reduce((max, c) => {
+		const span =
+			c.totalCount != null && pageSize > 0
+				? Math.max(1, Math.ceil(c.totalCount / pageSize))
+				: c.pageIndex + (c.hasNextPage ? 2 : 1);
+		return Math.max(max, span);
+	}, 0);
+
+	return {
+		pageIndex,
+		pageCount: totalCount === 0 ? 0 : pageCount,
+		pageSize,
+		pageSizeOptions,
+		hasNextPage: sources.some((c) => c.hasNextPage),
+		hasPreviousPage: pageIndex > 0,
+		totalCount,
+	};
+}
+
+/**
+ * Per-source mode: keeps only nodes from sources caught up to the current
+ * global page; a left-behind source already showed its final page earlier.
+ */
+export function filterToGlobalPage(
+	items: MergedResultItem[],
+	pageIndexBySource: Record<string, number>,
+	globalPageIndex: number,
+): MergedResultItem[] {
+	return items.filter((item) => pageIndexBySource[item.sourceKey] === globalPageIndex);
+}

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/features/search/utils/scope-utils.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import type { SearchConfig } from "../types/search-config.types";
+import { ALL_SCOPE, type SearchScope } from "../types/scope.types";
+
+/** True when `sourceKey` participates in the current scope. */
+export function isSourceInScope(scope: SearchScope, sourceKey: string): boolean {
+	return scope === ALL_SCOPE || scope === sourceKey;
+}
+
+/** Returns `raw` when it is "all" or a configured source key, else "all". */
+export function validateScope(config: SearchConfig, raw: string): SearchScope {
+	if (raw === ALL_SCOPE) return ALL_SCOPE;
+	return config.sources.some((s) => s.key === raw) ? raw : ALL_SCOPE;
+}

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/features/search/utils/sort-utils.ts

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import type { SortState } from "../types/sort.types";
+
+/**
+ * Sort state and order-by builder for search.
+ *
+ * The order-by output shape matches the Salesforce uiapi GraphQL convention:
+ *   { [field]: { order: ASC|DESC, nulls: LAST } }
+ *
+ * The constants are stringly-typed here (rather than imported from codegen)
+ * because search builds its query at runtime and isn't tied to a
+ * specific generated schema.
+ */
+
+const ORDER_ASC = "ASC";
+const ORDER_DESC = "DESC";
+const NULLS_LAST = "LAST";
+
+export function buildOrderBy(sort: SortState | null): unknown {
+	if (!sort) return undefined;
+	return {
+		[sort.field]: {
+			order: sort.direction === "ASC" ? ORDER_ASC : ORDER_DESC,
+			nulls: NULLS_LAST,
+		},
+	};
+}

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/features/search/utils/validate-config.spec.ts

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { describe, it, expect } from "vitest";
+import { validateSearchConfig } from "./validate-config";
+import type { SearchConfig, SObjectSourceConfig } from "../types/search-config.types";
+
+const source = (key: string, extra: Partial<SObjectSourceConfig> = {}): SObjectSourceConfig => ({
+	kind: "sobject",
+	key,
+	label: key,
+	objectName: "Account",
+	displayFields: ["Name"],
+	searchableFields: ["Name"],
+	...extra,
+});
+
+describe("validateSearchConfig", () => {
+	it("accepts a valid config", () => {
+		expect(() =>
+			validateSearchConfig({ sources: [source("a"), source("b")] } as SearchConfig),
+		).not.toThrow();
+	});
+
+	it("rejects an empty source list", () => {
+		expect(() => validateSearchConfig({ sources: [] } as unknown as SearchConfig)).toThrow(
+			/at least one/,
+		);
+	});
+
+	it("rejects duplicate keys and reserved prefixes", () => {
+		expect(() =>
+			validateSearchConfig({ sources: [source("a"), source("a")] } as SearchConfig),
+		).toThrow(/Duplicate source key/);
+		expect(() => validateSearchConfig({ sources: [source("__a")] } as SearchConfig)).toThrow(
+			/Invalid source key/,
+		);
+	});
+
+	it("rejects unsafe identifiers", () => {
+		expect(() =>
+			validateSearchConfig({ sources: [source("a", { objectName: "Account }" })] } as SearchConfig),
+		).toThrow(/Invalid objectName/);
+	});
+});

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/features/search/utils/validate-config.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { getAdapter } from "../adapters/registry";
+import type { SearchConfig } from "../types/search-config.types";
+
+/**
+ * Validates a {@link SearchConfig} up front: at least one source, unique source
+ * keys, and every name that is interpolated into a query document. Throws on the
+ * first problem so a bad config fails at startup, not at first search.
+ */
+export function validateSearchConfig(config: SearchConfig): void {
+	if (config.sources.length === 0) {
+		throw new Error("SearchConfig requires at least one source.");
+	}
+	const keys = new Set<string>();
+	for (const source of config.sources) {
+		if (keys.has(source.key)) {
+			throw new Error(`Duplicate source key "${source.key}". Source keys must be unique.`);
+		}
+		keys.add(source.key);
+		getAdapter(source.kind).validateSource(source);
+	}
+	const p = config.pagination;
+	if (p) {
+		if (!(p.pageSize > 0)) throw new Error("pagination.pageSize must be greater than 0.");
+		if (p.pageSizeOptions.some((n) => !(n > 0))) {
+			throw new Error("pagination.pageSizeOptions must contain only positive numbers.");
+		}
+	}
+}

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/pages/home/home.html

@@ -0,0 +1,6 @@
+<main class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-12">
+	<div class="text-center">
+		<h1 class="text-4xl font-bold text-gray-900 mb-4">Home</h1>
+		<p class="text-lg text-gray-600 mb-8">Welcome to your Angular application.</p>
+	</div>
+</main>

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/pages/home/home.spec.ts

@@ -0,0 +1,23 @@
+import { TestBed } from '@angular/core/testing';
+import { HomeComponent } from './home';
+
+describe('HomeComponent', () => {
+	beforeEach(async () => {
+		await TestBed.configureTestingModule({
+			imports: [HomeComponent],
+		}).compileComponents();
+	});
+
+	it('should create the component', () => {
+		const fixture = TestBed.createComponent(HomeComponent);
+		const component = fixture.componentInstance;
+		expect(component).toBeTruthy();
+	});
+
+	it('should render main landmark', async () => {
+		const fixture = TestBed.createComponent(HomeComponent);
+		await fixture.whenStable();
+		const compiled = fixture.nativeElement as HTMLElement;
+		expect(compiled.querySelector('main')).toBeTruthy();
+	});
+});

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/pages/home/home.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+
+@Component({
+	selector: 'app-home',
+	changeDetection: ChangeDetectionStrategy.OnPush,
+	templateUrl: './home.html',
+})
+export class HomeComponent {}

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/pages/not-found/not-found.html

@@ -0,0 +1,12 @@
+<main class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-12">
+	<div class="text-center">
+		<h1 class="text-4xl font-bold text-gray-900 mb-4">404</h1>
+		<p class="text-lg text-gray-600 mb-8">Page not found</p>
+		<a
+			routerLink="/"
+			class="inline-block px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700 transition-colors"
+		>
+			Go to Home
+		</a>
+	</div>
+</main>

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/pages/not-found/not-found.spec.ts

@@ -0,0 +1,33 @@
+import { TestBed } from '@angular/core/testing';
+import { provideRouter } from '@angular/router';
+import { NotFoundComponent } from './not-found';
+
+describe('NotFoundComponent', () => {
+	beforeEach(async () => {
+		await TestBed.configureTestingModule({
+			imports: [NotFoundComponent],
+			providers: [provideRouter([])],
+		}).compileComponents();
+	});
+
+	it('should create the component', () => {
+		const fixture = TestBed.createComponent(NotFoundComponent);
+		const component = fixture.componentInstance;
+		expect(component).toBeTruthy();
+	});
+
+	it('should render main landmark', async () => {
+		const fixture = TestBed.createComponent(NotFoundComponent);
+		await fixture.whenStable();
+		const compiled = fixture.nativeElement as HTMLElement;
+		expect(compiled.querySelector('main')).toBeTruthy();
+	});
+
+	it('should have a link to home', async () => {
+		const fixture = TestBed.createComponent(NotFoundComponent);
+		await fixture.whenStable();
+		const compiled = fixture.nativeElement as HTMLElement;
+		const link = compiled.querySelector('a');
+		expect(link?.getAttribute('href')).toBe('/');
+	});
+});

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/pages/not-found/not-found.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { RouterLink } from '@angular/router';
+
+@Component({
+	selector: 'app-not-found',
+	changeDetection: ChangeDetectionStrategy.OnPush,
+	imports: [RouterLink],
+	templateUrl: './not-found.html',
+})
+export class NotFoundComponent {}

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/pages/search/search-page.html

@@ -0,0 +1,5 @@
+<app-search
+	[config]="config"
+	title="Search"
+	searchPlaceholder="Search accounts, contacts, and opportunities..."
+/>

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/pages/search/search-page.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+import { ChangeDetectionStrategy, Component } from "@angular/core";
+import { SearchComponent } from "../../features/search/components/search/search";
+import { defaultSearchConfig } from "../../features/search/default-search-config";
+
+/** The `/search` route: the drop-in search over the starter config. */
+@Component({
+	selector: "app-search-page",
+	changeDetection: ChangeDetectionStrategy.OnPush,
+	imports: [SearchComponent],
+	templateUrl: "./search-page.html",
+})
+export class SearchPageComponent {
+	protected readonly config = defaultSearchConfig;
+}

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/shared/alert/hlm-alert-action.ts

@@ -0,0 +1,14 @@
+import { Directive } from '@angular/core';
+import { classes } from '@spartan-ng/styles/utils';
+
+@Directive({
+	selector: '[hlmAlertAction]',
+	host: {
+		'data-slot': 'alert-action',
+	},
+})
+export class HlmAlertAction {
+	constructor() {
+		classes(() => 'absolute end-2 top-2');
+	}
+}