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

package/dist/force-app/main/default/uiBundles/feature-angular-search/eslint.config.js

@@ -0,0 +1,77 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import js from '@eslint/js';
+import angular from 'angular-eslint';
+import { defineConfig } from 'eslint/config';
+import tseslint from 'typescript-eslint';
+import { createPlugin } from './eslint-plugin-angular-graphql.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const schemaPath = resolve(__dirname, '../../../../../schema.graphql');
+const angularGraphqlPlugin = createPlugin({ schemaPath });
+
+export default defineConfig(
+	// Global ignores
+	{
+		ignores: [
+			'dist/**/*',
+			'.angular/**/*',
+			'coverage/**/*',
+			'node_modules/**/*',
+			// Vendored Spartan primitives use upstream hlm*/brn* selectors and are
+			// not authored here, so they can't satisfy the app-prefix/a11y rules.
+			'**/shared/**',
+		],
+	},
+	// TypeScript files
+	{
+		files: ['**/*.ts'],
+		extends: [
+			js.configs.recommended,
+			...tseslint.configs.recommended,
+			...angular.configs.tsRecommended,
+		],
+		rules: {
+			'@angular-eslint/directive-selector': [
+				'error',
+				{
+					type: 'attribute',
+					prefix: 'app',
+					style: 'camelCase',
+				},
+			],
+			'@angular-eslint/component-selector': [
+				'error',
+				{
+					type: 'element',
+					prefix: 'app',
+					style: 'kebab-case',
+				},
+			],
+			// The UI wrapper components (app-button, app-card, …) intentionally
+			// alias an input to `class` so callers can write `class="…"` on the host
+			// and have it forward to the inner Material element. Allow that one name.
+			'@angular-eslint/no-input-rename': ['error', { allowedNames: ['class'] }],
+			'@typescript-eslint/no-unused-vars': [
+				'error',
+				{
+					argsIgnorePattern: '^_',
+					varsIgnorePattern: '^_',
+					caughtErrorsIgnorePattern: '^_',
+					ignoreRestSiblings: true,
+				},
+			],
+			'@typescript-eslint/no-explicit-any': 'off',
+			'@typescript-eslint/explicit-function-return-type': 'off',
+			'@typescript-eslint/explicit-module-boundary-types': 'off',
+		},
+	},
+	// Template files
+	{
+		files: ['**/*.html'],
+		extends: [...angular.configs.templateRecommended, ...angular.configs.templateAccessibility],
+		rules: {},
+	},
+	// Inline template processor + GraphQL rules (plugin handles schema detection)
+	...angularGraphqlPlugin.configs,
+);

package/dist/force-app/main/default/uiBundles/feature-angular-search/feature-angular-search.uibundle-meta.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<UIBundle xmlns="http://soap.sforce.com/2006/04/metadata">
+    <masterLabel>feature-angular-search</masterLabel>
+    <description>A Salesforce UI Bundle.</description>
+    <isActive>true</isActive>
+    <version>1</version>
+</UIBundle>

package/dist/force-app/main/default/uiBundles/feature-angular-search/middleware/html.mjs

@@ -0,0 +1,3 @@
+import { createHtmlMiddleware } from '@salesforce/angular-plugin-ui-bundle';
+
+export default await createHtmlMiddleware();

package/dist/force-app/main/default/uiBundles/feature-angular-search/middleware/proxy.mjs

@@ -0,0 +1,12 @@
+/**
+ * Proxy middleware for Angular CLI dev server.
+ *
+ * Forwards `/services/*` and other manifest-routed paths to the connected
+ * Salesforce org with authentication. Watches `ui-bundle.json` for changes
+ * and recreates the proxy handler automatically (manual browser refresh needed).
+ *
+ * Referenced from angular.json: architect.serve.options.middlewares[].
+ */
+import { createProxyMiddleware } from '@salesforce/angular-plugin-ui-bundle';
+
+export default await createProxyMiddleware();

package/dist/force-app/main/default/uiBundles/feature-angular-search/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "base-angular-app",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "dev": "sf-angular-serve",
+    "dev:design": "sf-angular-serve --design",
+    "build": "ng lint && ng build",
+    "watch": "ng build --watch --configuration development",
+    "test": "ng test",
+    "lint": "ng lint",
+    "build:e2e": "ng lint && ng build && node scripts/rewrite-e2e-assets.mjs",
+    "e2e": "playwright test",
+    "graphql:schema": "node scripts/get-graphql-schema.mjs",
+    "graphql:codegen": "graphql-codegen"
+  },
+  "dependencies": {
+    "@angular/cdk": "^21.2.0",
+    "@angular/common": "^21.2.0",
+    "@angular/compiler": "^21.2.0",
+    "@angular/core": "^21.2.0",
+    "@angular/forms": "^21.2.0",
+    "@angular/platform-browser": "^21.2.0",
+    "@angular/router": "^21.2.0",
+    "@ng-icons/core": "^32.2.0",
+    "@ng-icons/lucide": "^32.2.0",
+    "@salesforce/angular-plugin-ui-bundle": "^12.14.0",
+    "@salesforce/platform-sdk": "^12.14.0",
+    "@spartan-ng/brain": "^1.3.1",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "rxjs": "~7.8.0",
+    "tailwind-merge": "^3.5.0",
+    "tslib": "^2.3.0"
+  },
+  "devDependencies": {
+    "@angular-builders/custom-esbuild": "^21.0.0",
+    "@angular-eslint/builder": "^21.0.0",
+    "@angular/build": "^21.2.11",
+    "@angular/cli": "^21.2.11",
+    "@angular/compiler-cli": "^21.2.0",
+    "@eslint/js": "^9.0.0",
+    "@graphql-codegen/cli": "^6.1.0",
+    "@graphql-codegen/typescript-operations": "^5.0.6",
+    "@graphql-eslint/eslint-plugin": "^4.1.0",
+    "@playwright/test": "^1.49.0",
+    "@spartan-ng/cli": "^1.3.1",
+    "@tailwindcss/postcss": "^4.0.0",
+    "angular-eslint": "^21.0.0",
+    "eslint": "^9.0.0",
+    "graphql": "^16.11.0",
+    "graphql-codegen-typescript-operation-types": "^2.0.2",
+    "jsdom": "^28.0.0",
+    "postcss": "^8.5.0",
+    "serve": "^14.2.5",
+    "tailwindcss": "^4.0.0",
+    "typescript": "~5.9.2",
+    "typescript-eslint": "^8.71.2",
+    "vitest": "^4.1.11",
+    "@salesforce/graphiti": "^12.14.0"
+  },
+  "overrides": {
+    "undici": "^7.28.0"
+  }
+}

package/dist/force-app/main/default/uiBundles/feature-angular-search/playwright.config.ts

@@ -0,0 +1,25 @@
+import { defineConfig, devices } from '@playwright/test';
+
+const E2E_PORT = 5176;
+
+export default defineConfig({
+	testDir: './e2e',
+	fullyParallel: true,
+	forbidOnly: !!process.env.CI,
+	retries: process.env.CI ? 2 : 0,
+	workers: process.env.CI ? 1 : undefined,
+	reporter: 'html',
+	use: {
+		baseURL: `http://localhost:${E2E_PORT}`,
+		trace: 'on-first-retry',
+	},
+	projects: [{ name: 'chromium', use: { ...devices['Desktop Chrome'] } }],
+	webServer: {
+		// Serve built dist/ with a static server so e2e works in CI without an SF org
+		// (ng serve runs the SF plugin/proxy middleware and can fail without an org).
+		command: `npx serve dist -l ${E2E_PORT}`,
+		url: `http://localhost:${E2E_PORT}`,
+		reuseExistingServer: !process.env.CI,
+		timeout: process.env.CI ? 120_000 : 60_000,
+	},
+});

package/dist/force-app/main/default/uiBundles/feature-angular-search/scripts/get-graphql-schema.mjs

@@ -0,0 +1,69 @@
+/**
+ * Downloads the full GraphQL schema from a connected Salesforce org via introspection.
+ *
+ * Usage:
+ *   npm run graphql:schema
+ *   node scripts/get-graphql-schema.mjs [output-path]
+ *
+ * The default output path matches the schema location expected by codegen.yml
+ * and .graphqlrc.yml so that codegen and IDE tooling resolve it automatically.
+ */
+import { writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { getOrgInfo } from '@salesforce/ui-bundle/app';
+import { buildClientSchema, getIntrospectionQuery, printSchema } from 'graphql';
+import { pruneSchema } from '@graphql-tools/utils';
+
+const DEFAULT_SCHEMA_PATH = '../../../../../schema.graphql';
+const TARGET_ORG = process.env.SF_TARGET_ORG || undefined;
+
+async function executeSalesforceGraphQLQuery(query, variables, operationName) {
+	const orgInfo = await getOrgInfo(TARGET_ORG);
+	if (!orgInfo) {
+		throw new Error('Could not resolve a Salesforce org. Set SF_TARGET_ORG or a default org.');
+	}
+	const { rawInstanceUrl: instanceUrl, apiVersion, accessToken } = orgInfo;
+
+	const targetUrl = `${instanceUrl}/services/data/v${apiVersion}/graphql`;
+
+	console.log(`Executing introspection query against ${targetUrl}`);
+	const response = await fetch(targetUrl, {
+		method: 'POST',
+		headers: {
+			Authorization: `Bearer ${accessToken}`,
+			'Content-Type': 'application/json',
+			'X-Chatter-Entity-Encoding': 'false',
+		},
+		body: JSON.stringify({ query, variables, operationName }),
+	});
+
+	if (!response.ok) {
+		const errorText = await response.text();
+		throw new Error(
+			`Salesforce GraphQL request failed: ${response.status} ${response.statusText} - ${errorText}`,
+		);
+	}
+
+	return response.json();
+}
+
+try {
+	const outputPath = resolve(process.argv[2] || DEFAULT_SCHEMA_PATH);
+
+	const introspectionResult = await executeSalesforceGraphQLQuery(
+		getIntrospectionQuery(),
+		{},
+		'IntrospectionQuery',
+	);
+
+	const schema = buildClientSchema(introspectionResult.data);
+	const prunedSchema = pruneSchema(schema);
+	const sdl = printSchema(prunedSchema);
+
+	writeFileSync(outputPath, sdl);
+
+	console.log(`Schema saved to ${outputPath}`);
+} catch (error) {
+	console.error('Error:', error.message);
+	process.exit(1);
+}

package/dist/force-app/main/default/uiBundles/feature-angular-search/scripts/rewrite-e2e-assets.mjs

@@ -0,0 +1,30 @@
+/**
+ * Prepares dist/ for e2e: root-relative asset paths + SPA fallback for serve.
+ *
+ * angular.json sets deployUrl: "./", so the built index.html references
+ * scripts/styles with a relative "./" prefix (e.g. ./main-HASH.js). When the
+ * SPA fallback serves index.html for a deep route like /non-existent-route,
+ * those "./" paths resolve against the wrong base and 404, so the app never
+ * boots. Rewrite them to root-relative "/" paths.
+ */
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// angular.json outputPath: { base: "dist", browser: "" } -> files land in dist/
+const distDir = join(__dirname, '..', 'dist');
+
+// Rewrite index.html so asset paths are root-relative (./main-x.js -> /main-x.js)
+const indexPath = join(distDir, 'index.html');
+let html = readFileSync(indexPath, 'utf8');
+html = html.replace(/(src|href)="\.\//g, '$1="/');
+writeFileSync(indexPath, html);
+
+// SPA fallback so /non-existent-route etc. serve index.html
+writeFileSync(
+	join(distDir, 'serve.json'),
+	JSON.stringify({
+		rewrites: [{ source: '**', destination: '/index.html' }],
+	}),
+);

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/api/data-client.service.spec.ts

@@ -0,0 +1,184 @@
+import { TestBed } from '@angular/core/testing';
+import { DataClient } from './data-client.service';
+import { createDataSDK } from '@salesforce/platform-sdk';
+
+vi.mock('@salesforce/platform-sdk', () => ({
+	createDataSDK: vi.fn(),
+}));
+
+describe('DataClient', () => {
+	let service: DataClient;
+	let mockGraphqlQuery: ReturnType<typeof vi.fn>;
+	let mockGraphqlMutate: ReturnType<typeof vi.fn>;
+	let mockFetch: ReturnType<typeof vi.fn>;
+
+	beforeEach(async () => {
+		mockGraphqlQuery = vi.fn();
+		mockGraphqlMutate = vi.fn();
+		mockFetch = vi.fn();
+
+		vi.mocked(createDataSDK).mockResolvedValue({
+			graphql: {
+				query: mockGraphqlQuery,
+				mutate: mockGraphqlMutate,
+			},
+			fetch: mockFetch,
+		} as any);
+
+		await TestBed.configureTestingModule({
+			providers: [DataClient],
+		}).compileComponents();
+
+		service = TestBed.inject(DataClient);
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it('should create the service', () => {
+		expect(service).toBeTruthy();
+		expect(service).toBeInstanceOf(DataClient);
+	});
+
+	it('should route plain query operations to graphql.query and return result.data', async () => {
+		const operation = 'query { user { id name } }';
+		const expectedData = { user: { id: '123', name: 'Test User' } };
+		mockGraphqlQuery.mockResolvedValue({ data: expectedData });
+
+		const result = await service.execute(operation);
+
+		expect(mockGraphqlQuery).toHaveBeenCalledWith({ query: operation, variables: undefined });
+		expect(mockGraphqlMutate).not.toHaveBeenCalled();
+		expect(result).toEqual(expectedData);
+	});
+
+	it('should route anonymous query operations to graphql.query', async () => {
+		const operation = '{ user { id name } }';
+		const expectedData = { user: { id: '456', name: 'Anonymous User' } };
+		mockGraphqlQuery.mockResolvedValue({ data: expectedData });
+
+		const result = await service.execute(operation);
+
+		expect(mockGraphqlQuery).toHaveBeenCalledWith({ query: operation, variables: undefined });
+		expect(mockGraphqlMutate).not.toHaveBeenCalled();
+		expect(result).toEqual(expectedData);
+	});
+
+	it('should route mutation operations to graphql.mutate', async () => {
+		const operation = 'mutation { updateUser(id: "123", name: "New Name") { id name } }';
+		const expectedData = { updateUser: { id: '123', name: 'New Name' } };
+		mockGraphqlMutate.mockResolvedValue({ data: expectedData });
+
+		const result = await service.execute(operation);
+
+		expect(mockGraphqlMutate).toHaveBeenCalledWith({ mutation: operation, variables: undefined });
+		expect(mockGraphqlQuery).not.toHaveBeenCalled();
+		expect(result).toEqual(expectedData);
+	});
+
+	it('should detect mutation with leading GraphQL comment and route to graphql.mutate', async () => {
+		const operation = '# This is a comment\nmutation { deleteUser(id: "123") { success } }';
+		const expectedData = { deleteUser: { success: true } };
+		mockGraphqlMutate.mockResolvedValue({ data: expectedData });
+
+		const result = await service.execute(operation);
+
+		expect(mockGraphqlMutate).toHaveBeenCalledWith({ mutation: operation, variables: undefined });
+		expect(mockGraphqlQuery).not.toHaveBeenCalled();
+		expect(result).toEqual(expectedData);
+	});
+
+	it('should not treat query as mutation when comment contains "mutation" word', async () => {
+		const operation = '# this is not a mutation, just a query\nquery { user { id } }';
+		const expectedData = { user: { id: '789' } };
+		mockGraphqlQuery.mockResolvedValue({ data: expectedData });
+
+		const result = await service.execute(operation);
+
+		expect(mockGraphqlQuery).toHaveBeenCalledWith({ query: operation, variables: undefined });
+		expect(mockGraphqlMutate).not.toHaveBeenCalled();
+		expect(result).toEqual(expectedData);
+	});
+
+	it('should throw error when result.errors contains errors', async () => {
+		const operation = 'query { user { id } }';
+		mockGraphqlQuery.mockResolvedValue({
+			data: null,
+			errors: [{ message: 'Field not found' }, { message: 'Permission denied' }],
+		});
+
+		await expect(service.execute(operation)).rejects.toThrow(
+			'GraphQL Error: Field not found; Permission denied',
+		);
+	});
+
+	it('should throw error when result.errors contains a single error', async () => {
+		const operation = 'query { user { id } }';
+		mockGraphqlQuery.mockResolvedValue({
+			data: null,
+			errors: [{ message: 'Unauthorized' }],
+		});
+
+		await expect(service.execute(operation)).rejects.toThrow('GraphQL Error: Unauthorized');
+	});
+
+	it('should throw error when result.data is null with no errors', async () => {
+		const operation = 'query { user { id } }';
+		mockGraphqlQuery.mockResolvedValue({ data: null });
+
+		await expect(service.execute(operation)).rejects.toThrow('GraphQL response data is null');
+	});
+
+	it('should pass variables through to graphql.query', async () => {
+		const operation = 'query GetUser($id: ID!) { user(id: $id) { id name } }';
+		const variables = { id: '999' };
+		const expectedData = { user: { id: '999', name: 'Variable User' } };
+		mockGraphqlQuery.mockResolvedValue({ data: expectedData });
+
+		const result = await service.execute(operation, variables);
+
+		expect(mockGraphqlQuery).toHaveBeenCalledWith({ query: operation, variables });
+		expect(result).toEqual(expectedData);
+	});
+
+	it('should pass variables through to graphql.mutate', async () => {
+		const operation =
+			'mutation UpdateUser($id: ID!, $name: String!) { updateUser(id: $id, name: $name) { id name } }';
+		const variables = { id: '888', name: 'Updated Name' };
+		const expectedData = { updateUser: { id: '888', name: 'Updated Name' } };
+		mockGraphqlMutate.mockResolvedValue({ data: expectedData });
+
+		const result = await service.execute(operation, variables);
+
+		expect(mockGraphqlMutate).toHaveBeenCalledWith({ mutation: operation, variables });
+		expect(result).toEqual(expectedData);
+	});
+
+	it('should proxy fetch to sdk.fetch and return the raw Response', async () => {
+		const url = '/services/apexrest/auth/login';
+		const init: RequestInit = {
+			method: 'POST',
+			body: JSON.stringify({ email: 'a@b.com' }),
+			headers: { 'Content-Type': 'application/json' },
+		};
+		const expectedResponse = { ok: true, status: 200 } as Response;
+		mockFetch.mockResolvedValue(expectedResponse);
+
+		const response = await service.fetch(url, init);
+
+		expect(mockFetch).toHaveBeenCalledWith(url, init);
+		expect(response).toBe(expectedResponse);
+	});
+
+	it('should call fetch with no init when omitted', async () => {
+		const url = '/services/data/v64.0/chatter/users/me';
+		const expectedResponse = { ok: true, status: 200 } as Response;
+		mockFetch.mockResolvedValue(expectedResponse);
+
+		const response = await service.fetch(url);
+
+		expect(mockFetch).toHaveBeenCalledWith(url, undefined);
+		expect(response).toBe(expectedResponse);
+	});
+});

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/api/data-client.service.ts

@@ -0,0 +1,74 @@
+import { Injectable } from '@angular/core';
+import { createDataSDK } from '@salesforce/platform-sdk';
+
+/**
+ * True when the operation's first definition is a `mutation`. Strips GraphQL
+ * comments first so a leading `# ...` line can't mask the keyword. Queries
+ * (named or anonymous `{ ... }` shorthand) and subscriptions fall through to
+ * query().
+ */
+function isMutation(operation: string): boolean {
+	return /^\s*mutation\b/.test(operation.replace(/#[^\n\r]*/g, ''));
+}
+
+/**
+ * The single data-access client for the app — a thin wrapper over
+ * `createDataSDK` that centralizes both of the SDK's surfaces:
+ *
+ * - `execute()` for GraphQL (routes mutations to `sdk.graphql.mutate` and
+ *   everything else to `sdk.graphql.query`, with centralized error handling).
+ *   Use with gql-tagged queries and generated operation types for type-safe
+ *   calls.
+ * - `fetch()` for REST (proxies `sdk.fetch`, returning the raw `Response` so
+ *   callers keep full control over response parsing / error shaping).
+ *
+ * Consumers inject this instead of calling `createDataSDK` directly, so the SDK
+ * bootstrap lives in exactly one place. Feature packages consume it via an
+ * `__inherit__data-client.service` stub (base wins at compose).
+ */
+@Injectable({ providedIn: 'root' })
+export class DataClient {
+	/**
+	 * Executes a GraphQL operation and returns its `data`, throwing on GraphQL
+	 * errors or a null payload.
+	 */
+	async execute<TData, TVariables = Record<string, unknown>>(
+		operation: string,
+		variables?: TVariables,
+	): Promise<TData> {
+		const data = await createDataSDK();
+		const result = isMutation(operation)
+			? await data.graphql!.mutate<TData, TVariables>({
+					mutation: operation,
+					variables,
+				})
+			: await data.graphql!.query<TData, TVariables>({
+					query: operation,
+					variables,
+				});
+
+		if (result.errors?.length) {
+			const msg = result.errors.map((e) => e.message).join('; ');
+			throw new Error(`GraphQL Error: ${msg}`);
+		}
+
+		if (result.data == null) {
+			throw new Error('GraphQL response data is null');
+		}
+
+		return result.data;
+	}
+
+	/**
+	 * Performs a REST request through the SDK's authenticated `fetch`, returning
+	 * the raw `Response`. Callers parse the body / shape errors themselves (e.g.
+	 * via `handleApiResponse`).
+	 *
+	 * @param input - The request URL (e.g. an Apex REST route).
+	 * @param init  - Standard `fetch` options (method, headers, body, …).
+	 */
+	async fetch(input: string, init?: RequestInit): Promise<Response> {
+		const sdk = await createDataSDK();
+		return sdk.fetch!(input, init);
+	}
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+import { ApplicationConfig, provideBrowserGlobalErrorListeners } from '@angular/core';
+import { provideRouter } from '@angular/router';
+import { provideNativeDateAdapter as provideBrnNativeDateAdapter } from '@spartan-ng/brain/date-time';
+import { provideNgIconsConfig } from '@ng-icons/core';
+
+import { routes } from './app.routes';
+
+export const appConfig: ApplicationConfig = {
+	providers: [
+		provideBrowserGlobalErrorListeners(),
+		provideRouter(routes),
+		provideBrnNativeDateAdapter(),
+		provideNgIconsConfig({ size: '1rem' }),
+	],
+};

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

@@ -0,0 +1 @@
+<router-outlet />

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

@@ -0,0 +1,27 @@
+import { Routes } from '@angular/router';
+import { AppLayoutComponent } from './components/layout/app-layout/app-layout';
+import { HomeComponent } from './pages/home/home';
+import { NotFoundComponent } from './pages/not-found/not-found';
+import { SearchPageComponent } from "./pages/search/search-page";
+
+export const routes: Routes = [
+  {
+    path: "",
+    component: AppLayoutComponent,
+    children: [
+      {
+        path: '',
+        component: HomeComponent
+      },
+      {
+        path: "search",
+        component: SearchPageComponent,
+        data: { showInNavigation: true, label: "Search" }
+      },
+      {
+        path: '**',
+        component: NotFoundComponent
+      }
+    ]
+  }
+];

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

@@ -0,0 +1,18 @@
+import { TestBed } from '@angular/core/testing';
+import { provideRouter } from '@angular/router';
+import { App } from './app';
+
+describe('App', () => {
+	beforeEach(async () => {
+		await TestBed.configureTestingModule({
+			imports: [App],
+			providers: [provideRouter([])],
+		}).compileComponents();
+	});
+
+	it('should create the app', () => {
+		const fixture = TestBed.createComponent(App);
+		const app = fixture.componentInstance;
+		expect(app).toBeTruthy();
+	});
+});

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/app.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 { RouterOutlet } from '@angular/router';
+
+@Component({
+	selector: 'app-root',
+	changeDetection: ChangeDetectionStrategy.OnPush,
+	imports: [RouterOutlet],
+	templateUrl: './app.html',
+})
+export class App {}