@salesforce/templates 66.3.0 → 66.3.2

package/lib/templates/project/reactb2x/force-app/main/default/webapplications/appreacttemplateb2x/src/features/global-search/utils/graphQLObjectInfoAdapter.ts

@@ -0,0 +1,319 @@
+/**
+ * GraphQL objectInfos → REST-compatible object info and picklist.
+ *
+ * graphQLObjectInfoToObjectInfoResult / graphQLObjectInfosToBatchResponse: used by objectInfoService
+ * after getObjectInfosGraphQL. extractPicklistValuesFromGraphQLObjectInfo: used for getPicklistValues.
+ * Normalizes casing and adds synthetic compound fields (e.g. BillingAddress) for layout/dataType.
+ *
+ * @module utils/graphQLObjectInfoAdapter
+ */
+
+import type {
+	ObjectInfoBatchResponse,
+	ObjectInfoResult,
+	Field,
+	RecordTypeInfo,
+	ThemeInfo,
+} from "../types/objectInfo/objectInfo";
+import type { PicklistValue } from "../types/filters/picklist";
+
+type GraphQLNode = Record<string, unknown>;
+
+function getStr(node: GraphQLNode, key: string): string {
+	const v = node[key] ?? node[key.charAt(0).toLowerCase() + key.slice(1)];
+	return typeof v === "string" ? v : "";
+}
+
+function getNum(node: GraphQLNode, key: string): number {
+	const v = node[key] ?? node[key.charAt(0).toLowerCase() + key.slice(1)];
+	return typeof v === "number" ? v : 0;
+}
+
+function getBool(node: GraphQLNode, key: string): boolean {
+	const v = node[key] ?? node[key.charAt(0).toLowerCase() + key.slice(1)];
+	return typeof v === "boolean" ? v : false;
+}
+
+function getArr<T>(node: GraphQLNode, key: string, map: (item: unknown) => T): T[] {
+	const v = node[key] ?? node[key.charAt(0).toLowerCase() + key.slice(1)];
+	if (!Array.isArray(v)) return [];
+	return v.map((item) => map(item));
+}
+
+function getObj(node: GraphQLNode, key: string): Record<string, unknown> {
+	const v = node[key] ?? node[key.charAt(0).toLowerCase() + key.slice(1)];
+	return v != null && typeof v === "object" && !Array.isArray(v)
+		? (v as Record<string, unknown>)
+		: {};
+}
+
+/** GraphQL returns dependentFields as [DependentField]; REST expects Record. Normalize to object. */
+function toDependentFieldsRecord(v: unknown): Record<string, unknown> {
+	if (v == null) return {};
+	if (Array.isArray(v)) return {};
+	return typeof v === "object" ? (v as Record<string, unknown>) : {};
+}
+
+/** Canonical dataType casing for formatters (Phone, FormattedAddress) and reference resolution (Reference). */
+const DATA_TYPE_CANONICAL: Record<string, string> = {
+	phone: "Phone",
+	email: "Email",
+	url: "Url",
+	address: "Address",
+	reference: "Reference",
+};
+
+function normalizeDataType(raw: string): string {
+	if (!raw) return raw;
+	const lower = raw.toLowerCase();
+	return DATA_TYPE_CANONICAL[lower] ?? raw;
+}
+
+/** Normalize GraphQL Field to our Field type (REST-compatible). */
+function mapField(fieldNode: unknown): [string, Field] {
+	const n = (fieldNode != null && typeof fieldNode === "object" ? fieldNode : {}) as GraphQLNode;
+	const apiName = getStr(n, "ApiName") || getStr(n, "apiName");
+	const label = getStr(n, "label");
+	const dataType = normalizeDataType(getStr(n, "dataType"));
+	const relationshipName = getStr(n, "relationshipName") || null;
+	const reference = getBool(n, "reference");
+	const compound = getBool(n, "compound");
+	const compoundFieldName = getStr(n, "compoundFieldName") || null;
+	const compoundComponentName = getStr(n, "compoundComponentName") || null;
+	const controllingFields = getArr(n, "controllingFields", String);
+	const controllerName = getStr(n, "controllerName") || null;
+	const referenceToInfos = getArr(n, "referenceToInfos", (item) => {
+		const r = (item != null && typeof item === "object" ? item : {}) as GraphQLNode;
+		return {
+			apiName: getStr(r, "apiName") || getStr(r, "ApiName"),
+			nameFields: getArr(r, "nameFields", String),
+		};
+	});
+	return [
+		apiName,
+		{
+			apiName,
+			label,
+			dataType,
+			relationshipName,
+			reference,
+			compound,
+			compoundFieldName,
+			compoundComponentName,
+			controllingFields,
+			controllerName,
+			referenceToInfos,
+			calculated: getBool(n, "calculated"),
+			createable: getBool(n, "createable"),
+			custom: getBool(n, "custom"),
+			defaultValue: n.defaultValue ?? null,
+			defaultedOnCreate: getBool(n, "defaultedOnCreate"),
+			digits: getNum(n, "digits"),
+			externalId: getBool(n, "externalId"),
+			extraTypeInfo: getStr(n, "extraTypeInfo") || null,
+			filterable: getBool(n, "filterable"),
+			filteredLookupInfo: null,
+			highScaleNumber: getBool(n, "highScaleNumber"),
+			htmlFormatted: getBool(n, "htmlFormatted"),
+			inlineHelpText: getStr(n, "inlineHelpText") || null,
+			length: getNum(n, "length"),
+			maskType: getStr(n, "maskType") || null,
+			nameField: getBool(n, "nameField"),
+			polymorphicForeignKey: getBool(n, "polymorphicForeignKey"),
+			precision: getNum(n, "precision"),
+			required: getBool(n, "required"),
+			scale: getNum(n, "scale"),
+			searchPrefilterable: getBool(n, "searchPrefilterable"),
+			sortable: getBool(n, "sortable"),
+			unique: getBool(n, "unique"),
+			updateable: getBool(n, "updateable"),
+			referenceTargetField: getStr(n, "referenceTargetField") || null,
+		} as Field,
+	];
+}
+
+/** Normalize GraphQL recordTypeInfo to RecordTypeInfo. */
+function mapRecordTypeInfo(rtNode: unknown): [string, RecordTypeInfo] {
+	const n = (rtNode != null && typeof rtNode === "object" ? rtNode : {}) as GraphQLNode;
+	const recordTypeId = getStr(n, "recordTypeId");
+	return [
+		recordTypeId,
+		{
+			recordTypeId,
+			name: getStr(n, "name"),
+			master: getBool(n, "master"),
+			available: getBool(n, "available"),
+			defaultRecordTypeMapping: getBool(n, "defaultRecordTypeMapping"),
+		} as RecordTypeInfo,
+	];
+}
+
+function toFieldsMap(fieldsNode: unknown): Record<string, Field> {
+	if (fieldsNode == null) return {};
+	if (Array.isArray(fieldsNode)) {
+		return Object.fromEntries((fieldsNode as unknown[]).map(mapField).filter(([k]) => k));
+	}
+	if (typeof fieldsNode === "object" && !Array.isArray(fieldsNode)) {
+		const entries = Object.entries(fieldsNode as Record<string, unknown>).map(([, v]) =>
+			mapField(v),
+		);
+		return Object.fromEntries(entries.filter(([k]) => k));
+	}
+	return {};
+}
+
+/**
+ * Ensures compound parent fields (e.g. BillingAddress, ShippingAddress) exist in the fields map
+ * with dataType "Address" so layout transform can set item.dataType for FormattedAddress.
+ * GraphQL may only return component fields (BillingStreet, etc.) with compoundFieldName.
+ */
+function ensureCompoundParentFields(fields: Record<string, Field>): Record<string, Field> {
+	const result = { ...fields };
+	for (const field of Object.values(fields)) {
+		const compoundName = field.compoundFieldName;
+		if (!compoundName || result[compoundName] != null) continue;
+		const dataType =
+			compoundName.endsWith("Address") || compoundName.endsWith("address") ? "Address" : "String";
+		result[compoundName] = {
+			...field,
+			apiName: compoundName,
+			label: compoundName,
+			dataType,
+			compound: true,
+			compoundFieldName: null,
+			compoundComponentName: null,
+		} as Field;
+	}
+	return result;
+}
+
+function toRecordTypeInfosMap(rtNode: unknown): Record<string, RecordTypeInfo> {
+	if (rtNode == null) return {};
+	if (Array.isArray(rtNode)) {
+		return Object.fromEntries((rtNode as unknown[]).map(mapRecordTypeInfo).filter(([k]) => k));
+	}
+	if (typeof rtNode === "object" && !Array.isArray(rtNode)) {
+		const entries = Object.entries(rtNode as Record<string, unknown>).map(([, v]) =>
+			mapRecordTypeInfo(v),
+		);
+		return Object.fromEntries(entries.filter(([k]) => k));
+	}
+	return {};
+}
+
+/** Map a single GraphQL ObjectInfo node to ObjectInfoResult (REST-compatible). */
+export function graphQLObjectInfoToObjectInfoResult(node: GraphQLNode): ObjectInfoResult {
+	const themeInfoNode = getObj(node, "themeInfo");
+	const themeInfo: ThemeInfo = {
+		color: getStr(themeInfoNode, "color"),
+		iconUrl: getStr(themeInfoNode, "iconUrl"),
+	};
+
+	const childRelationships = getArr(node, "childRelationships", (item) => {
+		const c = (item != null && typeof item === "object" ? item : {}) as GraphQLNode;
+		return {
+			childObjectApiName: getStr(c, "childObjectApiName"),
+			fieldName: getStr(c, "fieldName"),
+			junctionIdListNames: getArr(c, "junctionIdListNames", String),
+			junctionReferenceTo: getArr(c, "junctionReferenceTo", String),
+			relationshipName: getStr(c, "relationshipName"),
+		};
+	});
+
+	const apiName = getStr(node, "ApiName") || getStr(node, "apiName");
+	const fieldsNode = node.fields ?? node.Fields;
+	const recordTypeInfosNode = node.recordTypeInfos ?? node.RecordTypeInfos;
+
+	return {
+		apiName,
+		label: getStr(node, "label"),
+		labelPlural: getStr(node, "labelPlural"),
+		nameFields: getArr(node, "nameFields", String),
+		defaultRecordTypeId: getStr(node, "defaultRecordTypeId") || "012000000000000AAA",
+		keyPrefix: getStr(node, "keyPrefix"),
+		layoutable: getBool(node, "layoutable"),
+		queryable: getBool(node, "queryable"),
+		searchable: getBool(node, "searchable"),
+		updateable: getBool(node, "updateable"),
+		deletable: getBool(node, "deletable"),
+		createable: getBool(node, "createable"),
+		custom: getBool(node, "custom"),
+		mruEnabled: getBool(node, "mruEnabled"),
+		feedEnabled: getBool(node, "feedEnabled"),
+		fields: ensureCompoundParentFields(toFieldsMap(fieldsNode)),
+		recordTypeInfos: toRecordTypeInfosMap(recordTypeInfosNode),
+		themeInfo,
+		childRelationships,
+		associateEntityType: getStr(node, "associateEntityType") || null,
+		associateParentEntity: getStr(node, "associateParentEntity") || null,
+		compactLayoutable: getBool(node, "compactLayoutable"),
+		searchLayoutable: getBool(node, "searchLayoutable"),
+		dependentFields: toDependentFieldsRecord(node.dependentFields ?? node.DependentFields),
+		eTag: getStr(node, "eTag"),
+	} as ObjectInfoResult;
+}
+
+/** Convert GraphQL objectInfos array to ObjectInfoBatchResponse (REST shape). */
+export function graphQLObjectInfosToBatchResponse(
+	nodes: GraphQLNode[],
+	_requestedApiNames: string[],
+): ObjectInfoBatchResponse {
+	const results = nodes.map((node) => ({
+		result: graphQLObjectInfoToObjectInfoResult(node),
+		statusCode: 200,
+	}));
+	return { results } as ObjectInfoBatchResponse;
+}
+
+/**
+ * Extract picklist values for a field from a GraphQL ObjectInfo node (raw response).
+ * Uses picklistValuesByRecordTypeIDs; prefers the given recordTypeId or first available.
+ */
+export function extractPicklistValuesFromGraphQLObjectInfo(
+	node: GraphQLNode,
+	fieldName: string,
+	recordTypeId?: string,
+): PicklistValue[] {
+	const fieldsNode = node.fields ?? node.Fields;
+	if (fieldsNode == null || typeof fieldsNode !== "object") return [];
+	const fieldMap = Array.isArray(fieldsNode)
+		? Object.fromEntries(
+				(fieldsNode as unknown[]).map((f: unknown) => {
+					const n = (f != null && typeof f === "object" ? f : {}) as GraphQLNode;
+					const k = getStr(n, "ApiName") || getStr(n, "apiName");
+					return [k, n];
+				}),
+			)
+		: (fieldsNode as Record<string, GraphQLNode>);
+	const field = fieldMap[fieldName];
+	if (!field || typeof field !== "object") return [];
+	const picklistData = field.picklistValuesByRecordTypeIDs ?? field.PicklistValuesByRecordTypeIDs;
+	if (!picklistData || !Array.isArray(picklistData)) return [];
+	const rtId = recordTypeId ?? "012000000000000AAA";
+	const arr = picklistData as Array<Record<string, unknown>>;
+	const byRecordType = arr.find((p) => (p.recordTypeID ?? p.recordTypeId) === rtId);
+	if (!byRecordType) {
+		const first = arr[0];
+		if (!first) return [];
+		return mapPicklistValues(first);
+	}
+	return mapPicklistValues(byRecordType);
+}
+
+function mapPicklistValues(byRecordType: Record<string, unknown>): PicklistValue[] {
+	const raw = byRecordType.picklistValues;
+	if (!Array.isArray(raw)) return [];
+	return raw.map((item: unknown) => {
+		const n = (item != null && typeof item === "object" ? item : {}) as Record<string, unknown>;
+		return {
+			label: typeof n.label === "string" ? n.label : "",
+			value: typeof n.value === "string" ? n.value : "",
+			validFor: Array.isArray(n.validFor) ? n.validFor : undefined,
+			attributes: (n.attributes != null && typeof n.attributes === "object"
+				? n.attributes
+				: undefined) as Record<string, unknown> | undefined,
+			defaultValue: typeof n.defaultValue === "boolean" ? n.defaultValue : undefined,
+			active: typeof n.active === "boolean" ? n.active : undefined,
+		} as PicklistValue;
+	});
+}

package/lib/templates/project/reactb2x/force-app/main/default/webapplications/appreacttemplateb2x/src/features/global-search/utils/graphQLRecordAdapter.ts

@@ -0,0 +1,90 @@
+/**
+ * Adapts GraphQL UI API node shape to SearchResultRecordData so existing list UI
+ * (SearchResultCard, ResultCardFields, getNestedFieldValue) works unchanged.
+ *
+ * GraphQL node: { Id, Name: { value }, Owner: { Alias: { value } }, ... }
+ * SearchResultRecordData: { id, fields: Record<string, FieldValue>, apiName, ... }
+ * FieldValue: { displayValue, value }
+ */
+
+import type { FieldValue, SearchResultRecordData } from "../types/search/searchResults";
+
+function isValueLeaf(obj: unknown): obj is { value: string | number | boolean | null } {
+	return (
+		typeof obj === "object" &&
+		obj !== null &&
+		"value" in obj &&
+		(Object.keys(obj).length === 1 || (Object.keys(obj).length === 2 && "displayValue" in obj))
+	);
+}
+
+function graphQLValueToFieldValue(val: unknown): FieldValue {
+	if (val === null || val === undefined) {
+		return { displayValue: null, value: null };
+	}
+	if (isValueLeaf(val)) {
+		const v = val.value;
+		const display =
+			typeof v === "string" || typeof v === "number" || typeof v === "boolean" ? v : null;
+		return { displayValue: display as string | null, value: v };
+	}
+	if (typeof val === "object" && val !== null && !Array.isArray(val)) {
+		const nested = graphQLNodeToFields(val as Record<string, unknown>);
+		const firstFv = nested && Object.values(nested)[0];
+		const display =
+			firstFv && typeof (firstFv as FieldValue).value !== "object"
+				? ((firstFv as FieldValue).value as string | null)
+				: null;
+		return { displayValue: display, value: { fields: nested ?? {} } };
+	}
+	return { displayValue: null, value: val };
+}
+
+function graphQLNodeToFields(node: Record<string, unknown>): Record<string, FieldValue> {
+	const fields: Record<string, FieldValue> = {};
+	for (const [key, val] of Object.entries(node)) {
+		if (key === "Id" || val === undefined) continue;
+		fields[key] = graphQLValueToFieldValue(val);
+	}
+	return fields;
+}
+
+/**
+ * Converts a GraphQL connection node (from getRecordsGraphQL) to SearchResultRecordData
+ * so it can be passed to SearchResultCard and other components that expect the keyword-search record shape.
+ */
+export function graphQLNodeToSearchResultRecordData(
+	node: Record<string, unknown> | undefined,
+	objectApiName: string,
+): SearchResultRecordData {
+	if (!node || typeof node !== "object") {
+		return {
+			id: "",
+			apiName: objectApiName,
+			childRelationships: {},
+			eTag: "",
+			fields: {},
+			lastModifiedById: null,
+			lastModifiedDate: null,
+			recordTypeId: null,
+			recordTypeInfo: null,
+			systemModstamp: null,
+			weakEtag: 0,
+		};
+	}
+	const id = (node.Id as string) ?? "";
+	const fields = graphQLNodeToFields(node);
+	return {
+		id,
+		apiName: objectApiName,
+		childRelationships: {},
+		eTag: "",
+		fields,
+		lastModifiedById: null,
+		lastModifiedDate: null,
+		recordTypeId: null,
+		recordTypeInfo: null,
+		systemModstamp: null,
+		weakEtag: 0,
+	};
+}

package/lib/templates/project/reactb2x/force-app/main/default/webapplications/appreacttemplateb2x/src/features/global-search/utils/index.ts

@@ -0,0 +1,59 @@
+// ---------------------------------------------------------------------------
+// Utilities
+// ---------------------------------------------------------------------------
+export { fetchAndValidate, safeEncodePath } from "./apiUtils";
+export type { FetchAndValidateOptions } from "./apiUtils";
+export { createFiltersKey } from "./cacheUtils";
+export { calculateFieldsToFetch, getSafeKey, isValidSalesforceId } from "./recordUtils";
+export {
+	getNestedFieldValue,
+	getRecordDisplayName,
+	toRecordDisplayNameMetadata,
+	getDisplayValueForLayoutItem,
+	getDisplayValueForDetailField,
+	formatAddressFromConstituents,
+	formatAddressDisplay,
+	formatDateTimeForDisplay,
+	isAddressConstituents,
+	getAddressPartsFromConstituents,
+	extractFieldValue,
+} from "./fieldUtils";
+export type {
+	AddressParts,
+	LayoutItemDisplayResult,
+	RecordDisplayNameMetadata,
+} from "./fieldUtils";
+export { calculateFormData } from "./formDataTransformUtils";
+export type { ObjectInfoMetadata } from "./formDataTransformUtils";
+export { getTransformedSections } from "./layoutTransformUtils";
+export type {
+	ObjectInfo,
+	ObjectInfoField,
+	PicklistOption,
+	LayoutTransformContext,
+	TransformedLayoutItem,
+	TransformedLayoutRow,
+	TransformedSection,
+} from "./layoutTransformUtils";
+export { parseFilterValue } from "./filterUtils";
+export { sanitizeFilterValue } from "./sanitizationUtils";
+export { getFormValueByPath, getUniqueErrors, validateRangeValues, isFormError } from "./formUtils";
+export type { FormError } from "./formUtils";
+export {
+	PAGE_SIZE_OPTIONS,
+	VALID_PAGE_SIZES,
+	getValidPageSize,
+	isValidPageSize,
+} from "./paginationUtils";
+export { isAllowedLinkUrl, ALLOWED_LINK_PROTOCOLS } from "./linkUtils";
+export { graphQLNodeToSearchResultRecordData } from "./graphQLRecordAdapter";
+export {
+	getGraphQLNodeValue,
+	getDisplayValueForLayoutItemFromNode,
+	getDisplayValueForDetailFieldFromNode,
+	getGraphQLRecordDisplayName,
+} from "./graphQLNodeFieldUtils";
+export type {
+	GraphQLRecordDisplayNameMetadata,
+	ObjectMetadataForDisplay,
+} from "./graphQLNodeFieldUtils";

package/lib/templates/project/reactb2x/force-app/main/default/webapplications/appreacttemplateb2x/src/features/global-search/utils/layoutTransformUtils.ts

@@ -0,0 +1,236 @@
+/**
+ * Transforms Layout API sections into a structure for the detail form: section → rows → items.
+ * Uses layout response (sections, layoutRows, layoutItems, layoutComponents) and optional
+ * object info for compound field names and dataType. Section merge when useHeading === false.
+ */
+
+import type { LayoutSection, LayoutRow, LayoutItem } from "../types/recordDetail/recordDetail";
+
+const HIDE_EMPTY_SECTIONS = true;
+const EMPTY_OPTIONS: PicklistOption[] = [];
+
+export interface ObjectInfoField {
+	compoundFieldName?: string;
+	dataType?: string;
+}
+
+export interface ObjectInfo {
+	apiName?: string;
+	fields?: Record<string, ObjectInfoField>;
+}
+
+/** Picklist/lookup options for a field (e.g. [{ label, value }]). */
+export type PicklistOption = {
+	label: string | null;
+	value: string | number | boolean;
+	validFor?: unknown[];
+};
+
+export interface LayoutTransformContext {
+	recordId: string;
+	objectInfo?: ObjectInfo | null;
+	lookupRecords?: Record<string, PicklistOption[] | null> | null;
+	getSectionCollapsedState: (sectionId: string) => boolean;
+	calculatePicklistValues?: (itemApiName: string, item: LayoutItem) => PicklistOption[] | null;
+	formOverrides?: { fieldVariant?: string } | null;
+}
+
+export interface TransformedLayoutItem {
+	key: string;
+	isField: boolean;
+	label?: string;
+	required?: boolean;
+	readOnly?: boolean;
+	apiName?: string;
+	contextName?: string;
+	options?: PicklistOption[];
+	variant?: string;
+	dataType?: string;
+	layoutComponentApiNames?: string[];
+}
+
+/** Single row in a section. */
+export interface TransformedLayoutRow {
+	key: string;
+	layoutItems: TransformedLayoutItem[];
+}
+
+/** Section ready for Section/SectionRow rendering. */
+export interface TransformedSection {
+	id: string;
+	key: string;
+	heading: string;
+	useHeading: boolean;
+	collapsible: boolean;
+	collapsed: boolean;
+	layoutRows: TransformedLayoutRow[];
+}
+
+export function createSectionKey(index: number): string {
+	return "section-" + index;
+}
+
+export function getTransformedSections(
+	sections: LayoutSection[],
+	transformContext: LayoutTransformContext,
+): TransformedSection[] {
+	const calculatedSections: TransformedSection[] = [];
+	let previousSection: TransformedSection | null = null;
+
+	sections.forEach((section, index) => {
+		if (previousSection !== null && section.useHeading === false) {
+			const sectionKey = createSectionKey(index);
+			const appendedRows = section.layoutRows
+				.map((row, i) => rowTransform(row, i, sectionKey, transformContext))
+				.filter((r): r is TransformedLayoutRow => r !== null);
+			previousSection.layoutRows.push(...appendedRows);
+			return;
+		}
+
+		const newSection = sectionTransform(section, index, transformContext);
+		if (newSection) {
+			calculatedSections.push(newSection);
+			previousSection = newSection;
+		}
+	});
+
+	return calculatedSections;
+}
+
+export function sectionTransform(
+	section: LayoutSection,
+	index: number,
+	transformContext: LayoutTransformContext,
+): TransformedSection | null {
+	const { getSectionCollapsedState } = transformContext;
+	const sectionKey = createSectionKey(index);
+	const layoutRows = section.layoutRows
+		.map((row, i) => rowTransform(row, i, sectionKey, transformContext))
+		.filter((r): r is TransformedLayoutRow => r !== null);
+
+	if (layoutRows.length === 0 && HIDE_EMPTY_SECTIONS) {
+		return null;
+	}
+
+	return {
+		key: sectionKey,
+		collapsible: section.collapsible,
+		collapsed: getSectionCollapsedState(section.id),
+		useHeading: section.useHeading,
+		heading: section.heading,
+		id: section.id,
+		layoutRows,
+	};
+}
+
+export function rowTransform(
+	row: LayoutRow,
+	index: number,
+	sectionKey: string,
+	transformContext: LayoutTransformContext,
+): TransformedLayoutRow | null {
+	const layoutItems = row.layoutItems.map((item, i) => transformItem(item, i, transformContext));
+
+	const allItemsHaveNoComponents = layoutItems.every((item) => !item.apiName || !item.isField);
+	if (allItemsHaveNoComponents) {
+		return null;
+	}
+	return {
+		key: sectionKey + "-" + index,
+		layoutItems,
+	};
+}
+
+export function transformItem(
+	item: LayoutItem,
+	index: number,
+	transformContext: LayoutTransformContext,
+): TransformedLayoutItem {
+	const { recordId, objectInfo, lookupRecords, calculatePicklistValues, formOverrides } =
+		transformContext;
+
+	let itemApiName: string | undefined;
+	let itemComponentType: string | undefined;
+
+	if (item.layoutComponents.length >= 1) {
+		const itemComponent = item.layoutComponents[0];
+		itemComponentType = itemComponent.componentType;
+		const componentApiName = itemComponent.apiName;
+		const topLevelCompoundName =
+			item.layoutComponents.length > 1 &&
+			componentApiName &&
+			objectInfo?.fields?.[componentApiName]?.compoundFieldName;
+		if (topLevelCompoundName) {
+			itemApiName = topLevelCompoundName;
+		} else {
+			itemApiName = componentApiName ?? undefined;
+		}
+	}
+
+	const lookupOptions =
+		itemApiName != null && lookupRecords?.[itemApiName] != null ? lookupRecords[itemApiName] : null;
+
+	const isFieldType = itemComponentType === "Field";
+
+	const options: PicklistOption[] =
+		lookupOptions ??
+		(itemApiName ? (calculatePicklistValues?.(itemApiName, item) ?? null) : null) ??
+		EMPTY_OPTIONS;
+
+	const fieldMeta = itemApiName ? objectInfo?.fields?.[itemApiName] : undefined;
+	const layoutComponentApiNames = item.layoutComponents
+		.filter((c) => c.componentType === "Field" && c.apiName != null)
+		.map((c) => c.apiName as string);
+
+	let newItem: TransformedLayoutItem = {
+		key: "item-" + index,
+		apiName: itemApiName,
+		contextName: recordId,
+		label: item.label,
+		required: item.required,
+		variant: formOverrides?.fieldVariant ?? "label-stacked",
+		readOnly: !item.editableForUpdate,
+		isField: isFieldType,
+		options,
+		dataType: fieldMeta?.dataType,
+		layoutComponentApiNames:
+			layoutComponentApiNames.length > 0 ? layoutComponentApiNames : undefined,
+	};
+
+	if (objectInfo?.apiName?.endsWith("__kav")) {
+		newItem = { ...newItem, readOnly: true };
+	}
+
+	if (newItem.required === true && newItem.readOnly === true) {
+		newItem = { ...newItem, required: false };
+	}
+
+	return newItem;
+}
+
+export function layoutReducer<T>(
+	sections: TransformedSection[],
+	reducer: (
+		acc: T,
+		ctx: {
+			section: TransformedSection;
+			layoutRow: TransformedLayoutRow;
+			layoutItem: TransformedLayoutItem;
+		},
+	) => T,
+	initialValue: T,
+): T {
+	let accumulator = initialValue;
+	sections.forEach((section) =>
+		section.layoutRows.forEach((layoutRow) =>
+			layoutRow.layoutItems.forEach((layoutItem) => {
+				accumulator = reducer(accumulator, {
+					section,
+					layoutRow,
+					layoutItem,
+				});
+			}),
+		),
+	);
+	return accumulator;
+}