@salesforce/webapp-template-app-react-sample-b2e-experimental 1.73.0 → 1.74.0

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/lib/filterUtils.ts

@@ -0,0 +1,165 @@
+/**
+ * Filter utilities: build FilterCriteria from form values and derive default form state.
+ * Multi-select filter values are stored as delimiter-separated; "in" operator is used when multiple values.
+ */
+import type {
+	Filter,
+	FilterCriteria,
+} from "@salesforce/webapp-template-feature-react-global-search-experimental";
+import {
+	parseFilterValue,
+	sanitizeFilterValue,
+} from "@salesforce/webapp-template-feature-react-global-search-experimental";
+
+/** Delimiter for multi-select form values. Picklist values must not contain this character. */
+export const MULTI_VALUE_SEP = "|";
+
+/** Placeholder value for "All" in single-select (Radix does not accept empty string). */
+export const ALL_PLACEHOLDER_VALUE = "__all__";
+
+/** Parses a stored select value into an array (single or multi). Excludes ALL_PLACEHOLDER_VALUE. */
+export function parseMultiSelectValue(raw: string): string[] {
+	if (!raw?.trim() || raw === ALL_PLACEHOLDER_VALUE) return [];
+	return raw
+		.split(MULTI_VALUE_SEP)
+		.map((s) => s.trim())
+		.filter((s) => s && s !== ALL_PLACEHOLDER_VALUE);
+}
+
+/** Form state key for range filter minimum value (suffix _min). */
+export function getRangeMinKey(fieldPath: string): string {
+	return `${fieldPath}_min`;
+}
+
+/** Form state key for range filter maximum value (suffix _max). */
+export function getRangeMaxKey(fieldPath: string): string {
+	return `${fieldPath}_max`;
+}
+
+/** Error message when range min > max. */
+export const RANGE_VALIDATION_ERROR_MESSAGE =
+	"Minimum value must be less than or equal to maximum value";
+
+/**
+ * Validates that min is less than or equal to max (when both are numeric).
+ */
+export function validateRangeValues(minRaw: string, maxRaw: string): string | null {
+	const minVal = parseFilterValue(minRaw);
+	const maxVal = parseFilterValue(maxRaw);
+	if (minVal === "" || maxVal === "") return null;
+	const minNum = typeof minVal === "number" ? minVal : Number(minVal);
+	const maxNum = typeof maxVal === "number" ? maxVal : Number(maxVal);
+	if (Number.isNaN(minNum) || Number.isNaN(maxNum)) return null;
+	if (minNum > maxNum) return RANGE_VALIDATION_ERROR_MESSAGE;
+	return null;
+}
+
+export interface BuildFilterCriteriaResult {
+	criteria: FilterCriteria[];
+	rangeError?: string;
+}
+
+/**
+ * Builds FilterCriteria[] from current filter form values.
+ * Validates range filters (min <= max). Returns rangeError when invalid.
+ */
+export function buildFilterCriteriaFromFormValues(
+	objectApiName: string,
+	filters: Filter[],
+	formValues: Record<string, string>,
+): BuildFilterCriteriaResult {
+	const criteria: FilterCriteria[] = [];
+	let rangeError: string | undefined;
+	for (const filter of filters) {
+		if (!filter?.targetFieldPath) continue;
+		const affordance = (filter.affordance ?? "").toLowerCase();
+
+		if (affordance === "range") {
+			const minKey = getRangeMinKey(filter.targetFieldPath);
+			const maxKey = getRangeMaxKey(filter.targetFieldPath);
+			const minValue = sanitizeFilterValue(formValues[minKey] ?? "");
+			const maxValue = sanitizeFilterValue(formValues[maxKey] ?? "");
+			if (minValue && maxValue) {
+				const err = validateRangeValues(minValue, maxValue);
+				if (err) {
+					rangeError = err;
+					continue;
+				}
+			}
+			if (minValue) {
+				const parsed = parseFilterValue(minValue);
+				if (parsed !== "") {
+					criteria.push({
+						objectApiName,
+						fieldPath: filter.targetFieldPath,
+						operator: "gte",
+						values: [parsed],
+					});
+				}
+			}
+			if (maxValue) {
+				const parsed = parseFilterValue(maxValue);
+				if (parsed !== "") {
+					criteria.push({
+						objectApiName,
+						fieldPath: filter.targetFieldPath,
+						operator: "lte",
+						values: [parsed],
+					});
+				}
+			}
+		} else {
+			const raw = formValues[filter.targetFieldPath] ?? "";
+			if (affordance === "select") {
+				const values = parseMultiSelectValue(raw)
+					.map((v) => sanitizeFilterValue(v))
+					.filter(Boolean);
+				if (values.length > 0) {
+					criteria.push({
+						objectApiName,
+						fieldPath: filter.targetFieldPath,
+						operator: values.length > 1 ? "in" : "eq",
+						values,
+					});
+				}
+			} else {
+				const fieldValue = sanitizeFilterValue(raw);
+				if (fieldValue) {
+					criteria.push({
+						objectApiName,
+						fieldPath: filter.targetFieldPath,
+						operator: "like",
+						values: [`%${fieldValue}%`],
+					});
+				}
+			}
+		}
+	}
+	return rangeError ? { criteria, rangeError } : { criteria };
+}
+
+/**
+ * Returns initial form values for the filter row (empty or from filter.defaultValues).
+ */
+export function getDefaultFilterFormValues(filters: Filter[]): Record<string, string> {
+	const values: Record<string, string> = {};
+	if (!filters?.length) return values;
+	for (const filter of filters) {
+		if (!filter?.targetFieldPath) continue;
+		const affordance = (filter.affordance ?? "").toLowerCase();
+		if (affordance === "range") {
+			values[getRangeMinKey(filter.targetFieldPath)] = filter.defaultValues?.[0] ?? "";
+			values[getRangeMaxKey(filter.targetFieldPath)] = filter.defaultValues?.[1] ?? "";
+		} else {
+			values[filter.targetFieldPath] = filter.defaultValues?.[0] ?? "";
+		}
+	}
+	return values;
+}
+
+/**
+ * Returns only filters whose targetFieldPath is not in the excluded set.
+ */
+export function getApplicableFilters(filters: Filter[], excludedFieldPaths: Set<string>): Filter[] {
+	return filters.filter((f) => f?.targetFieldPath && !excludedFieldPaths.has(f.targetFieldPath));
+}

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/lib/globalSearchConstants.ts

@@ -0,0 +1,40 @@
+/**
+ * Object API names and routes for list/search.
+ */
+import {
+	MAINTENANCE_WORKER_OBJECT_API_NAME,
+	FALLBACK_LABEL_PROPERTIES_PLURAL,
+	FALLBACK_LABEL_MAINTENANCE_PLURAL,
+	FALLBACK_LABEL_MAINTENANCE_WORKERS_PLURAL,
+	FALLBACK_LABEL_APPLICATIONS_PLURAL,
+} from "./constants.js";
+
+export const GLOBAL_SEARCH_OBJECT_API_NAME = "Property__c" as const;
+export const MAINTENANCE_OBJECT_API_NAME = "Maintenance_Request__c" as const;
+export const APPLICATION_OBJECT_API_NAME = "Application__c" as const;
+export { MAINTENANCE_WORKER_OBJECT_API_NAME };
+
+export const SEARCHABLE_OBJECTS = [
+	{
+		objectApiName: "Property__c" as const,
+		path: "/properties",
+		fallbackLabelPlural: FALLBACK_LABEL_PROPERTIES_PLURAL,
+	},
+	{
+		objectApiName: "Maintenance_Request__c" as const,
+		path: "/maintenance/requests",
+		fallbackLabelPlural: FALLBACK_LABEL_MAINTENANCE_PLURAL,
+	},
+	{
+		objectApiName: MAINTENANCE_WORKER_OBJECT_API_NAME,
+		path: "/maintenance/workers",
+		fallbackLabelPlural: FALLBACK_LABEL_MAINTENANCE_WORKERS_PLURAL,
+	},
+	{
+		objectApiName: "Application__c" as const,
+		path: "/applications",
+		fallbackLabelPlural: FALLBACK_LABEL_APPLICATIONS_PLURAL,
+	},
+] as const;
+
+export type SearchableObjectConfig = (typeof SEARCHABLE_OBJECTS)[number];

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/lib/listFilters.ts

@@ -0,0 +1,152 @@
+/**
+ * Shared filter types and client-side filter/search helpers for list pages.
+ * Used by Properties, Maintenance Requests, Maintenance Workers, and Applications.
+ * Supports both static filter config and FilterCriteria from the react-global-search filters API.
+ */
+
+import type { FilterCriteria } from "@salesforce/webapp-template-feature-react-global-search-experimental";
+
+export type FilterFieldType = "text" | "select";
+
+export interface FilterOption {
+	value: string;
+	label: string;
+}
+
+export interface FilterFieldConfig {
+	key: string;
+	label: string;
+	type: FilterFieldType;
+	options?: FilterOption[];
+	getValue?: (record: Record<string, unknown>) => string | number | undefined;
+}
+
+export interface ActiveFilter {
+	fieldKey: string;
+	value: string;
+}
+
+/**
+ * Returns true if the record matches the given filter (case-insensitive contains for text, exact for select).
+ */
+function recordMatchesFilter(
+	record: Record<string, unknown>,
+	fieldKey: string,
+	value: string,
+	getValue?: (record: Record<string, unknown>) => string | number | undefined,
+): boolean {
+	const raw = getValue ? getValue(record) : record[fieldKey];
+	const str = raw == null ? "" : String(raw).toLowerCase();
+	const v = value.trim().toLowerCase();
+	if (!v) return true;
+	return str.includes(v);
+}
+
+/**
+ * Filters a list of records by active filters. All filters must match (AND).
+ */
+export function applyFilters<T extends Record<string, unknown>>(
+	items: T[],
+	filters: ActiveFilter[],
+	fieldConfigs: Map<string, FilterFieldConfig>,
+): T[] {
+	if (filters.length === 0) return items;
+	return items.filter((item) =>
+		filters.every((f) => {
+			const config = fieldConfigs.get(f.fieldKey);
+			return recordMatchesFilter(
+				item as Record<string, unknown>,
+				f.fieldKey,
+				f.value,
+				config?.getValue,
+			);
+		}),
+	);
+}
+
+/**
+ * Filters items by a search query: matches if any of the searchFields (values from the record) contain the query.
+ */
+export function applySearch<T extends Record<string, unknown>>(
+	items: T[],
+	query: string,
+	searchFields: (keyof T)[],
+	getValue?: (item: T, key: keyof T) => string | number | undefined,
+): T[] {
+	const q = query.trim().toLowerCase();
+	if (!q) return items;
+	const get = getValue ?? ((item: T, key: keyof T) => item[key]);
+	return items.filter((item) =>
+		searchFields.some((key) => {
+			const val = get(item, key);
+			return val != null && String(val).toLowerCase().includes(q);
+		}),
+	);
+}
+
+/**
+ * Applies both search and filters: first search, then filters.
+ */
+export function applySearchAndFilters<T extends Record<string, unknown>>(
+	items: T[],
+	searchQuery: string,
+	searchFields: (keyof T)[],
+	activeFilters: ActiveFilter[],
+	fieldConfigs: Map<string, FilterFieldConfig>,
+	getSearchValue?: (item: T, key: keyof T) => string | number | undefined,
+): T[] {
+	const afterSearch = applySearch(items, searchQuery, searchFields, getSearchValue);
+	return applyFilters(afterSearch, activeFilters, fieldConfigs);
+}
+
+/**
+ * Returns true if the record value matches the FilterCriteria (operator + values).
+ * Used when filters come from the react-global-search getObjectListFilters API.
+ */
+function recordMatchesCriterion(
+	recordValue: string | number | undefined,
+	criterion: FilterCriteria,
+): boolean {
+	const raw = recordValue == null ? "" : String(recordValue);
+	const val = raw.toLowerCase();
+	const values = criterion.values.map((v) => (v == null ? "" : String(v).toLowerCase()));
+	if (values.length === 0 || values.every((v) => !v)) return true;
+	const op = criterion.operator;
+	if (op === "eq") return values.some((v) => val === v);
+	if (op === "ne") return values.every((v) => val !== v);
+	if (op === "like") {
+		// values may be like "%x%" from the API
+		return values.some((v) => {
+			const pattern = v.replace(/%/g, "");
+			return pattern ? val.includes(pattern) : true;
+		});
+	}
+	// numeric comparison
+	const numVal = parseFloat(raw);
+	const numValues = values.map((v) => parseFloat(v)).filter((n) => !Number.isNaN(n));
+	if (numValues.length === 0) return true;
+	if (op === "gt") return numValues.some((n) => numVal > n);
+	if (op === "gte") return numValues.some((n) => numVal >= n);
+	if (op === "lt") return numValues.some((n) => numVal < n);
+	if (op === "lte") return numValues.some((n) => numVal <= n);
+	return true;
+}
+
+/**
+ * Filters a list using FilterCriteria from the feature's filters API.
+ * getRecordValue(record, fieldPath) should return the record's value for the API field path
+ * (e.g. Status__c -> record.status, Type__c -> record.issueType for maintenance).
+ */
+export function applyFilterCriteria<T>(
+	items: T[],
+	criteria: FilterCriteria[],
+	getRecordValue: (record: T, fieldPath: string) => string | number | undefined,
+): T[] {
+	if (criteria.length === 0) return items;
+	return items.filter((item) =>
+		criteria.every((c) => {
+			const recordValue = getRecordValue(item, c.fieldPath);
+			return recordMatchesCriterion(recordValue, c);
+		}),
+	);
+}

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/lib/listPageConfig.ts

@@ -0,0 +1,65 @@
+/**
+ * Data-driven config for list pages with filters.
+ */
+import type { Column } from "@salesforce/webapp-template-feature-react-global-search-experimental";
+import {
+	MAINTENANCE_OBJECT_API_NAME,
+	MAINTENANCE_WORKER_OBJECT_API_NAME,
+	APPLICATION_OBJECT_API_NAME,
+} from "./globalSearchConstants.js";
+import { getMaintenanceColumns } from "./maintenanceColumns.js";
+import { getMaintenanceWorkerColumns } from "./maintenanceWorkerColumns.js";
+import { getApplicationListColumns } from "./applicationColumns.js";
+import {
+	MAINTENANCE_FILTER_EXCLUDED_FIELD_PATHS,
+	MAINTENANCE_WORKER_FILTER_EXCLUDED_FIELD_PATHS,
+	APPLICATION_FILTER_EXCLUDED_FIELD_PATHS,
+} from "./constants.js";
+import { nodeToMaintenanceRequest } from "./maintenanceAdapter.js";
+import { nodeToMaintenanceWorker } from "./maintenanceWorkerAdapter.js";
+import { nodeToApplication } from "./applicationAdapter.js";
+import type { MaintenanceRequest, MaintenanceWorker, Application } from "./types.js";
+
+export interface ListPageConfig<T> {
+	objectApiName: string;
+	getColumns: (listMetaColumns: Column[]) => Column[];
+	filterExcludedFieldPaths: Set<string>;
+	defaultSort: string;
+	nodeToItem: (node: unknown) => T;
+	loadingMessage: string;
+	filtersAriaLabel: string;
+	sortable: boolean;
+}
+
+export const maintenanceRequestsListConfig: ListPageConfig<MaintenanceRequest> = {
+	objectApiName: MAINTENANCE_OBJECT_API_NAME,
+	getColumns: getMaintenanceColumns,
+	filterExcludedFieldPaths: MAINTENANCE_FILTER_EXCLUDED_FIELD_PATHS,
+	defaultSort: "Priority__c DESC",
+	nodeToItem: (node) => nodeToMaintenanceRequest(node as Record<string, unknown>),
+	loadingMessage: "Loading maintenance requests...",
+	filtersAriaLabel: "Maintenance Requests filters",
+	sortable: false,
+};
+
+export const maintenanceWorkersListConfig: ListPageConfig<MaintenanceWorker> = {
+	objectApiName: MAINTENANCE_WORKER_OBJECT_API_NAME,
+	getColumns: getMaintenanceWorkerColumns,
+	filterExcludedFieldPaths: MAINTENANCE_WORKER_FILTER_EXCLUDED_FIELD_PATHS,
+	defaultSort: "Name ASC",
+	nodeToItem: (node) => nodeToMaintenanceWorker(node as Record<string, unknown>),
+	loadingMessage: "Loading maintenance workers...",
+	filtersAriaLabel: "Maintenance Workers filters",
+	sortable: true,
+};
+
+export const applicationsListConfig: ListPageConfig<Application> = {
+	objectApiName: APPLICATION_OBJECT_API_NAME,
+	getColumns: getApplicationListColumns,
+	filterExcludedFieldPaths: APPLICATION_FILTER_EXCLUDED_FIELD_PATHS,
+	defaultSort: "CreatedDate DESC",
+	nodeToItem: (node) => nodeToApplication(node as Record<string, unknown>),
+	loadingMessage: "Loading applications...",
+	filtersAriaLabel: "Applications filters",
+	sortable: false,
+};

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/lib/maintenanceAdapter.ts

@@ -0,0 +1,110 @@
+/**
+ * Adapter: maps Maintenance_Request__c GraphQL node to app MaintenanceRequest type.
+ */
+import type { MaintenanceRequest } from "./types.js";
+
+interface MaintenanceNode {
+	Id?: string;
+	Name?: { value?: string };
+	Description__c?: { value?: string };
+	Type__c?: { value?: string };
+	Priority__c?: { value?: string };
+	Status__c?: { value?: string };
+	Scheduled__c?: { value?: string };
+	Property__r?: {
+		Address__c?: { value?: string };
+		Name?: { value?: string };
+	};
+	User__r?: { Name?: { value?: string }; DisplayValue?: { value?: string } };
+	Owner?: { Name?: { value?: string } };
+	ContentDocumentLinks?: {
+		edges?: Array<{
+			node?: {
+				ContentDocument?: { LatestPublishedVersionId?: { value?: string } };
+			};
+		}>;
+	};
+	[key: string]: unknown;
+}
+
+function getTenantNameFromNode(n: MaintenanceNode): string {
+	const userRef = n.User__r;
+	if (!userRef || typeof userRef !== "object") return "Unknown";
+	const nameObj =
+		(userRef as Record<string, unknown>).Name ?? (userRef as Record<string, unknown>).name;
+	if (nameObj != null && typeof nameObj === "object" && "value" in nameObj) {
+		const v = (nameObj as { value?: string }).value;
+		if (typeof v === "string" && v.trim() !== "") return v;
+	}
+	const displayVal =
+		(userRef as Record<string, unknown>).DisplayValue ??
+		(userRef as Record<string, unknown>).displayValue;
+	if (displayVal != null && typeof displayVal === "object" && "value" in displayVal) {
+		const v = (displayVal as { value?: string }).value;
+		if (typeof v === "string" && v.trim() !== "") return v;
+	}
+	return "Unknown";
+}
+
+function mapPriority(priority: string | undefined): MaintenanceRequest["priority"] {
+	if (!priority) return "medium";
+	const p = priority.toLowerCase();
+	if (p.includes("emergency")) return "emergency";
+	if (p.includes("high") || p.includes("same day")) return "high";
+	if (p.includes("medium") || p.includes("standard")) return "medium";
+	if (p.includes("low")) return "low";
+	return "medium";
+}
+
+function mapStatus(status: string | undefined): string {
+	if (!status) return "new";
+	const s = status.toLowerCase().replace(/\s+/g, "_");
+	if (s === "completed" || s === "resolved") return "completed";
+	if (s === "in_progress") return "in_progress";
+	if (s === "assigned") return "assigned";
+	if (s === "scheduled") return "scheduled";
+	if (s === "new") return "new";
+	return "new";
+}
+
+export function nodeToMaintenanceRequest(
+	node: Record<string, unknown> | undefined,
+): MaintenanceRequest {
+	const n = (node ?? {}) as MaintenanceNode;
+	const scheduledDate = n.Scheduled__c?.value ? new Date(n.Scheduled__c.value) : null;
+	const formattedDate = scheduledDate
+		? scheduledDate.toLocaleDateString("en-US", { month: "short", day: "numeric" }) +
+			", " +
+			scheduledDate.toLocaleTimeString("en-US", {
+				hour: "numeric",
+				minute: "2-digit",
+				hour12: true,
+			})
+		: undefined;
+
+	const imageVersionId =
+		n.ContentDocumentLinks?.edges?.[0]?.node?.ContentDocument?.LatestPublishedVersionId?.value;
+	const imageUrl = imageVersionId
+		? `/sfc/servlet.shepherd/version/download/${imageVersionId}`
+		: undefined;
+
+	const tenantUnit = n.Property__r?.Name?.value ?? n.Property__r?.Address__c?.value;
+	const assignedWorkerName = n.Owner?.Name?.value ?? n.User__r?.Name?.value;
+
+	return {
+		id: n.Id ?? "",
+		propertyAddress: n.Property__r?.Address__c?.value ?? "Unknown Address",
+		issueType: n.Type__c?.value ?? "General",
+		priority: mapPriority(n.Priority__c?.value),
+		status: mapStatus(n.Status__c?.value),
+		assignedWorker: assignedWorkerName,
+		scheduledDateTime: scheduledDate?.toLocaleString(),
+		description: n.Description__c?.value ?? "",
+		tenantName: getTenantNameFromNode(n),
+		imageUrl,
+		tenantUnit,
+		assignedWorkerName: assignedWorkerName ?? undefined,
+		assignedWorkerOrg: undefined,
+		formattedDate,
+	};
+}

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/lib/maintenanceColumns.ts

@@ -0,0 +1,24 @@
+/**
+ * Column config for Maintenance_Request__c list.
+ */
+import type { Column } from "@salesforce/webapp-template-feature-react-global-search-experimental";
+
+export const MAINTENANCE_EXTRA_COLUMNS: Column[] = [
+	{ fieldApiName: "Description__c", label: "Description", searchable: true, sortable: false },
+	{
+		fieldApiName: "Property__r.Address__c",
+		label: "Property Address",
+		searchable: false,
+		sortable: false,
+	},
+	{ fieldApiName: "Property__r.Name", label: "Property Name", searchable: false, sortable: false },
+	{ fieldApiName: "User__r.Name", label: "User Name", searchable: false, sortable: false },
+	{ fieldApiName: "OwnerId", label: "Owner Id", searchable: false, sortable: false },
+	{ fieldApiName: "Owner", label: "Owner", searchable: false, sortable: false },
+];
+
+export function getMaintenanceColumns(columns: Column[]): Column[] {
+	const existing = new Set(columns.map((c) => c.fieldApiName));
+	const toAdd = MAINTENANCE_EXTRA_COLUMNS.filter((c) => !existing.has(c.fieldApiName));
+	return toAdd.length === 0 ? columns : [...columns, ...toAdd];
+}

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/lib/maintenanceWorkerAdapter.ts

@@ -0,0 +1,29 @@
+/**
+ * Adapter: maps Maintenance_Worker__c GraphQL node to app MaintenanceWorker type.
+ */
+import type { MaintenanceWorker } from "./types.js";
+
+interface MaintenanceWorkerNode {
+	Id?: string;
+	Name?: { value?: string };
+	Type__c?: { value?: string };
+	Phone__c?: { value?: string };
+	Location__c?: { value?: string };
+	IsActive__c?: { value?: boolean };
+	Employment_Type__c?: { value?: string };
+	[key: string]: unknown;
+}
+
+export function nodeToMaintenanceWorker(
+	node: Record<string, unknown> | undefined,
+): MaintenanceWorker {
+	const n = (node ?? {}) as MaintenanceWorkerNode;
+	const isActive = n.IsActive__c?.value;
+	return {
+		id: n.Id ?? "",
+		name: n.Name?.value ?? "",
+		phone: n.Phone__c?.value,
+		organization: n.Employment_Type__c?.value ?? n.Type__c?.value,
+		status: typeof isActive === "boolean" ? (isActive ? "Active" : "Inactive") : undefined,
+	};
+}

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/lib/maintenanceWorkerColumns.ts

@@ -0,0 +1,25 @@
+/**
+ * Column config for Maintenance_Worker__c list.
+ */
+import type { Column } from "@salesforce/webapp-template-feature-react-global-search-experimental";
+
+export const MAINTENANCE_WORKER_EXTRA_COLUMNS: Column[] = [
+	{ fieldApiName: "Name", label: "Worker Name", searchable: true, sortable: true },
+	{ fieldApiName: "Type__c", label: "Primary Skill", searchable: true, sortable: true },
+	{ fieldApiName: "Phone__c", label: "Phone", searchable: true, sortable: false },
+	{ fieldApiName: "Location__c", label: "Location", searchable: true, sortable: true },
+	{ fieldApiName: "IsActive__c", label: "Active", searchable: false, sortable: true },
+	{
+		fieldApiName: "Employment_Type__c",
+		label: "Employment Type",
+		searchable: true,
+		sortable: true,
+	},
+];
+
+export function getMaintenanceWorkerColumns(columns: Column[]): Column[] {
+	if (columns.length === 0) return MAINTENANCE_WORKER_EXTRA_COLUMNS;
+	const existing = new Set(columns.map((c) => c.fieldApiName));
+	const toAdd = MAINTENANCE_WORKER_EXTRA_COLUMNS.filter((c) => !existing.has(c.fieldApiName));
+	return toAdd.length === 0 ? columns : [...columns, ...toAdd];
+}

package/dist/force-app/main/default/webapplications/appreactsampleb2e/src/lib/objectApiNames.ts

@@ -0,0 +1,13 @@
+/**
+ * Salesforce object API names for list pages. Used to fetch filters from the
+ * react-global-search feature's getObjectListFilters API.
+ * Maintenance Workers has no SObject; use null and fall back to static filters.
+ */
+export const OBJECT_API_NAMES = {
+	properties: "Property__c",
+	maintenance_requests: "Maintenance_Request__c",
+	applications: "Application__c",
+	maintenance_workers: null as string | null,
+} as const;
+
+export type ObjectApiNameKey = keyof typeof OBJECT_API_NAMES;