@sapui5/sap.fe.base 1.149.0 → 1.151.0

package/src/sap/fe/base/BindingToolkit.ts

@@ -66,9 +66,7 @@ type BaseExpression<_T> = {
 
 /**
  * Collection of functions to support the manipulation of UI5 bindings
- * @public
  * @namespace
- * @ui5-experimental-since 1.145.0
  */
 export const bindingToolkitNamespace = "sap.fe.base.BindingToolkit";
 
@@ -217,8 +215,6 @@ function isActionParameter(serviceObject: unknown): serviceObject is ActionParam
 
 /**
  * A binding expression that evaluates to type T.
- * @public
- * @ui5-experimental-since 1.145.0
  */
 export type BindingToolkitExpression<T> =
 	| UnresolvablePathExpression
@@ -822,6 +818,86 @@ export function pathInModel<TargetType extends PrimitiveType>(
 	};
 }
 
+/**
+ * Transforms a binding path from a navigation property context to its parent context.
+ *
+ * This is used to transform a binding made for a NavProp context /MainObject/NavProp1/NavProp2
+ * into a binding on the previous context /MainObject/NavProp1.
+ * @param path The path string to transform
+ * @param partnerPath The optional partner navigation property name to check against
+ * @returns A binding expression for the upper context, or unresolvableExpression if the path cannot be transformed
+ */
+export function getBindingPathExpressionFromPartnerNavigation(path: string, partnerPath?: string): BindingToolkitExpression<unknown> {
+	if (path.startsWith("/")) {
+		// path is absolute it can be resolved from anywhere
+		return pathInModel(path);
+	}
+
+	if (partnerPath && path.startsWith(partnerPath + "/")) {
+		// Remove the partner navigation path prefix
+		return pathInModel(path.substring(partnerPath.length + 1));
+	} else {
+		return unresolvableExpression;
+	}
+}
+
+/**
+ * Recursively transforms an expression from a navigation property context to its parent context.
+ *
+ * This function walks through the expression tree and transforms all PathInModel expressions
+ * that reference relative paths (non-absolute, default model) using the partner navigation property.
+ * If the resulting expression contains unresolvable parts, the fallback value is returned instead.
+ * @template T The type of the binding expression
+ * @param expression The initial binding expression to transform
+ * @param partnerNavigationPropertyName The partner navigation property name to use for transformation
+ * @param fallbackValue The value to return if the expression becomes unresolvable
+ * @returns The transformed expression or the fallback value if unresolvable
+ */
+export function getBindingExpressionFromUpperContext<T extends PrimitiveType>(
+	expression: BindingToolkitExpression<T>,
+	partnerNavigationPropertyName: string | undefined,
+	fallbackValue: BindingToolkitExpression<T>
+): BindingToolkitExpression<T> {
+	if (expression._type === "Set") {
+		const newOperands = expression.operands.map((operand: BindingToolkitExpression<boolean>) =>
+			getBindingExpressionFromUpperContext(
+				operand,
+				partnerNavigationPropertyName,
+				fallbackValue as unknown as BindingToolkitExpression<boolean>
+			)
+		);
+
+		if (expression.operator === "||") {
+			return or(...(newOperands as unknown as BindingToolkitExpression<boolean>[])) as unknown as BindingToolkitExpression<T>;
+		} else {
+			return and(...(newOperands as unknown as BindingToolkitExpression<boolean>[])) as unknown as BindingToolkitExpression<T>;
+		}
+	}
+	// Transform PathInModel expressions using the partner navigation
+	const transformedExpression = transformRecursively<T, "PathInModel">(
+		expression,
+		"PathInModel",
+		(pathExpression: PathInModelExpression<T>) => {
+			// Only transform relative paths in the default model (modelName is undefined or empty)
+			if (!pathExpression.modelName || pathExpression.modelName === "") {
+				return getBindingPathExpressionFromPartnerNavigation(
+					pathExpression.path,
+					partnerNavigationPropertyName
+				) as BindingToolkitExpression<T>;
+			}
+			return pathExpression;
+		},
+		true // includeAllExpression - transform all expression types in the tree
+	);
+
+	// Check if the transformed expression contains unresolvable parts
+	if (hasUnresolvableExpression(transformedExpression)) {
+		return fallbackValue;
+	}
+
+	return transformedExpression;
+}
+
 type PlainExpressionObject = { [index: string]: BindingToolkitExpression<unknown> };
 
 /**
@@ -2491,6 +2567,63 @@ export function concat(...inExpressions: ExpressionOrPrimitive<string>[]): Bindi
 	};
 }
 
+/**
+ * Concatenate multiple expressions with a separator.
+ * @param separator The separator to insert between expressions
+ * @param inExpressions Expressions to concatenate
+ * @returns The concatenated expression
+ */
+export function concatWithSeparator(
+	separator: string,
+	...inExpressions: ExpressionOrPrimitive<string>[]
+): BindingToolkitExpression<string> {
+	const expressions = inExpressions.map(wrapPrimitive);
+	if (hasUnresolvableExpression(...expressions)) {
+		return unresolvableExpression;
+	}
+
+	const separatorConstant = constant(separator);
+
+	if (expressions.every(isConstant)) {
+		return constant(
+			expressions.reduce((concatenated: string, value, index) => {
+				const constantValue = value;
+				if (constantValue.value !== undefined && constantValue.value !== null) {
+					const prefix = index > 0 ? separator : "";
+					return concatenated + prefix + constantValue.value.toString();
+				}
+				return concatenated;
+			}, "")
+		);
+	}
+
+	// Interleave separator constants between expressions
+	const expressionsWithSeparators: BindingToolkitExpression<string>[] = [];
+	expressions.forEach((expr, index) => {
+		if (index > 0) {
+			expressionsWithSeparators.push(separatorConstant);
+		}
+		expressionsWithSeparators.push(expr);
+	});
+
+	if (expressionsWithSeparators.some(isComplexTypeExpression)) {
+		let pathIdx = 0;
+		const myConcatExpression = formatResult(expressionsWithSeparators, "._formatters.StandardFormatter#concat", undefined, true);
+		const allParts = [];
+		transformRecursively(myConcatExpression, "PathInModel", (constantPath: PathInModelExpression<unknown>) => {
+			allParts.push(constantPath);
+			return pathInModel(`$${pathIdx++}`, "$");
+		});
+		allParts.unshift(constant(JSON.stringify(myConcatExpression)));
+		return formatResult(allParts, "._formatters.StandardFormatter.bind($control)#evaluateComplexExpression", undefined, true);
+	}
+
+	return {
+		_type: "Concat",
+		expressions: expressionsWithSeparators
+	};
+}
+
 type ExpressionTypeToExpression<T extends ExpressionType, V> = T extends "Constant"
 	? ConstantExpression<V>
 	: T extends "PathInModel"
@@ -2838,6 +2971,42 @@ export function wrapBindingExpression(
 	}
 }
 
+/**
+ * Resolves a binding expression by substituting path values from preloaded data.
+ * Uses transformRecursively to replace PathInModel expressions with constants where values are available.
+ * Only resolves paths from the default (empty) model name.
+ * @template T The target type
+ * @param expression The binding toolkit expression to resolve
+ * @param preloadedValues A flat object with property paths as keys and their values
+ * @returns The resolved expression with PathInModel expressions replaced by constants where possible
+ */
+export function resolveWithPreloadedValues<T extends PrimitiveType>(
+	expression: ExpressionOrPrimitive<T>,
+	preloadedValues: Record<string, unknown>
+): BindingToolkitExpression<T> {
+	const expr = wrapPrimitive(expression);
+
+	return transformRecursively(
+		expr,
+		"PathInModel",
+		(pathExpression: PathInModelExpression<unknown>) => {
+			// Only resolve paths from the default model (empty model name)
+			if (pathExpression.modelName && pathExpression.modelName !== "") {
+				return pathExpression;
+			}
+
+			// Check if this path is in preloaded values
+			if (preloadedValues.hasOwnProperty(pathExpression.path)) {
+				return constant(preloadedValues[pathExpression.path] as T);
+			}
+
+			// Path not in preloaded values, return as-is
+			return pathExpression;
+		},
+		true
+	) as BindingToolkitExpression<T>;
+}
+
 /**
  * Compile an expression into an expression binding.
  * @template T The target type

package/src/sap/fe/base/BuildingBlockBase.js

@@ -149,14 +149,21 @@ sap.ui.define(["sap/fe/base/BindingToolkit", "sap/fe/base/ClassSupport", "sap/ui
 
     /**
      * This function (if available on the concrete control) provides the current accessibility state of the control.
-     * @returns The accessibility information for the control.
+     * When the content control is not visible, null is returned so that sap.m.Table can set aria-label=""
+     * on the gridcell, preventing screen reader virtual buffer bleed-through (ACC-264.1 / WCAG 2.1 Level A).
+     * @returns The accessibility information for the control, or null (cast) when content is not visible.
      */;
     _proto.getAccessibilityInfo = function getAccessibilityInfo() {
-      let accessibilityInfo = {};
       if (this.content?.isA("sap.ui.core.Control") && this.content.getAccessibilityInfo) {
-        accessibilityInfo = this.content.getAccessibilityInfo();
+        if (!this.content.getVisible()) {
+          // Content is not visible: return null (cast to preserve the type contract) so that
+          // sap.m.Table receives a falsy value and sets aria-label="" on the gridcell,
+          // preventing screen reader virtual buffer bleed-through (ACC-264.1 / WCAG 2.1 Level A).
+          return null;
+        }
+        return this.content.getAccessibilityInfo();
       }
-      return accessibilityInfo;
+      return {};
     }
 
     /**
@@ -186,8 +193,6 @@ sap.ui.define(["sap/fe/base/BindingToolkit", "sap/fe/base/ClassSupport", "sap/ui
      * Shorthand for the BindingToolkit.bindState function with the current state object.
      * @param path A property in the state object
      * @returns The binding toolkit expression for the state
-     * @public
-     * @ui5-experimental-since 1.145.0
      */;
     _proto.bindState = function bindState(path) {
       return BindingToolkit.bindState(this.state, path);
@@ -211,8 +216,6 @@ sap.ui.define(["sap/fe/base/BindingToolkit", "sap/fe/base/ClassSupport", "sap/ui
      * Framework hook for state change handling.
      * Subclasses can override this method to react to state changes.
      * @param _changedProps List of changed property names
-     * @public
-     * @ui5-experimental-since 1.145.0
      */;
     _proto.onStateChange = async function onStateChange(_changedProps) {};
     return BuildingBlockBase;
@@ -234,4 +237,4 @@ sap.ui.define(["sap/fe/base/BindingToolkit", "sap/fe/base/ClassSupport", "sap/ui
   }), _class2)) || _class);
   return BuildingBlockBase;
 }, false);
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["BuildingBlockBase","_dec","defineUI5Class","_dec2","aggregation","type","multiple","isDefault","_dec3","association","singularName","_dec4","defineState","_class","_class2","_Control","settings","others","scope","_this","id","call","_initializerDefineProperty","_descriptor","_descriptor2","_descriptor3","_oldDomRef","_inheritsLoose","_proto","prototype","getPlaceholder","_rm","render","oRm","oControl","content","getVisible","InvisibleRenderer","renderControl","setBindingContext","context","model","undefined","invalidate","bindProperty","name","bindingInfo","propertyMetadata","getMetadata","getProperty","bindable","group","onAfterRendering","event","domRef","getDomRef","WeakRef","suffix","oContent","deref","document","getElementById","getFocusDomRef","enhanceAccessibilityState","_oElement","mAriaProps","oParent","getParent","getAccessibilityInfo","accessibilityInfo","isA","getIdForLabel","addStyleClass","styleClass","removeStyleClass","bindState","path","BindingToolkit","state","syncStateProperty","propName","source","property","propBinding","getModel","STATE_MODEL_NAME","attachChange","onStateChange","_changedProps","Control","_applyDecoratedDescriptor","configurable","enumerable","writable","initializer"],"sourceRoot":".","sources":["BuildingBlockBase.ts"],"sourcesContent":["import type { BindingToolkitExpression, PrimitiveType } from \"sap/fe/base/BindingToolkit\";\nimport * as BindingToolkit from \"sap/fe/base/BindingToolkit\";\nimport type { GenericState, PropertiesOf, StateOf } from \"sap/fe/base/ClassSupport\";\nimport { aggregation, association, defineState, defineUI5Class, STATE_MODEL_NAME } from \"sap/fe/base/ClassSupport\";\nimport type ManagedObject from \"sap/ui/base/ManagedObject\";\nimport type { PropertyBindingInfo } from \"sap/ui/base/ManagedObject\";\nimport Control from \"sap/ui/core/Control\";\nimport type UI5Element from \"sap/ui/core/Element\";\nimport InvisibleRenderer from \"sap/ui/core/InvisibleRenderer\";\nimport type RenderManager from \"sap/ui/core/RenderManager\";\nimport type { AccessibilityInfo } from \"sap/ui/core/library\";\nimport type Context from \"sap/ui/model/Context\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ninterface BuildingBlockBase<T extends UI5Element = Control, K extends object = {}> {\n\t// Force a state update\n\t_updateState(): Promise<void>;\n}\n\n/**\n * Base class for building blocks.\n * This contains the low-level functionality of having a content aggregation and handling the rendering of the content without an actual DOM element.<br/>\n * The building block also defines a state object that can be used to store the state of the building block.<br/>\n * Accessibility and classes information are forwarded to the content control.<br/>\n * This class is not meant to be used directly, it's there for internal use only (and documentation)\n * @public\n */\n@defineUI5Class(\"sap.fe.base.BuildingBlockBase\")\nclass BuildingBlockBase<T extends UI5Element = Control, K extends object = {}> extends Control {\n\t/**\n\t * Optional content of generic type T.\n\t *\n\t * This property holds the main data or payload for the containing object.\n\t * When undefined, it indicates that no content has been set or is available.\n\t * The specific type and structure of the content depends on the generic type parameter T.\n\t * @public\n\t */\n\t@aggregation({ type: \"sap.ui.core.Element\", multiple: false, isDefault: true })\n\tcontent?: T;\n\n\t/**\n\t * Association to controls / IDs that label this control (see WAI-ARIA attribute aria-labelledby).\n\t * @public\n\t */\n\t@association({ type: \"sap.ui.core.Control\", multiple: true, singularName: \"ariaLabelledBy\" })\n\tariaLabelledBy!: string[];\n\n\t/**\n\t * The current state value of the component.\n\t *\n\t * This property holds the state data managed by the component, with the type\n\t * determined by the generic parameter K.\n\t * @public\n\t */\n\t@defineState()\n\tprotected state!: StateOf<K>;\n\n\tgetPlaceholder(_rm: RenderManager): void {}\n\n\tconstructor(settings?: string | PropertiesOf<BuildingBlockBase<T>>, others?: PropertiesOf<BuildingBlockBase<T>>, scope?: object) {\n\t\tif (typeof settings === \"string\") {\n\t\t\tothers ??= {};\n\t\t\tothers.id = settings;\n\t\t}\n\t\t// Scope is defined and is there, but somehow doesn't appear on all the children of ManagedObject\n\t\t// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n\t\t// @ts-ignore\n\t\tsuper(settings as unknown as string, others, scope);\n\t}\n\n\tprivate _oldDomRef: WeakRef<Element> | null = null;\n\n\tstatic render<T extends Control>(oRm: RenderManager, oControl: BuildingBlockBase<T>): void {\n\t\tif (!oControl.content || oControl.getVisible() === false) {\n\t\t\t// If there is no content, we render an invisible renderer to avoid the control being\n\t\t\tInvisibleRenderer.render(oRm, oControl);\n\t\t} else {\n\t\t\toControl.getPlaceholder?.(oRm);\n\t\t\toRm.renderControl(oControl.content);\n\t\t}\n\t}\n\n\tsetBindingContext(context: Context, model?: string): this {\n\t\tsuper.setBindingContext(context, model);\n\t\tif (model === undefined && context) {\n\t\t\tthis.invalidate();\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Override the bindProperty to deal with the case where the property is a binding info.\n\t * @param name The name of te property\n\t * @param bindingInfo The binding info\n\t * @returns The instance of the building block for chaining\n\t */\n\toverride bindProperty(name: string, bindingInfo: PropertyBindingInfo): this {\n\t\tconst propertyMetadata = this.getMetadata().getProperty(name);\n\t\tif (propertyMetadata?.bindable === false && propertyMetadata.group === \"Data\") {\n\t\t\t(this as Record<string, unknown>)[name] = bindingInfo;\n\t\t} else {\n\t\t\tsuper.bindProperty(name, bindingInfo);\n\t\t}\n\t\treturn this;\n\t}\n\n\t//set the old dom ref\n\toverride onAfterRendering(event: JQuery.Event): void {\n\t\tconst domRef = this.getDomRef();\n\t\tif (domRef) {\n\t\t\tthis._oldDomRef = new WeakRef(domRef);\n\t\t} else {\n\t\t\tthis._oldDomRef = null;\n\t\t}\n\t\tsuper.onAfterRendering(event);\n\t}\n\n\toverride getDomRef(suffix?: string): Element | null {\n\t\tconst oContent = this.content;\n\t\tlet domRef: Element | null = oContent?.getDomRef(suffix) ?? super.getDomRef(suffix);\n\t\tif (!domRef && !suffix) {\n\t\t\tdomRef = this._oldDomRef?.deref() ?? null;\n\t\t\tif (domRef) {\n\t\t\t\treturn document.getElementById(domRef.id);\n\t\t\t}\n\t\t}\n\t\treturn domRef;\n\t}\n\n\toverride getFocusDomRef(): Element | null {\n\t\tconst oContent = this.content;\n\t\treturn oContent ? oContent.getFocusDomRef() : super.getFocusDomRef();\n\t}\n\n\t/**\n\t * This function asks up the control tree to enhance the accessibility state of the control.\n\t * @param _oElement The element to enhance\n\t * @param mAriaProps The current aria properties\n\t * @returns The enhanced aria properties\n\t */\n\toverride enhanceAccessibilityState(_oElement: object, mAriaProps: object): object {\n\t\tconst oParent = this.getParent();\n\n\t\tif (oParent && (oParent as ManagedObject & { enhanceAccessibilityState?: Function }).enhanceAccessibilityState) {\n\t\t\t// forward  enhanceAccessibilityState call to the parent\n\t\t\t(oParent as ManagedObject & { enhanceAccessibilityState: Function }).enhanceAccessibilityState(_oElement, mAriaProps);\n\t\t}\n\n\t\treturn mAriaProps;\n\t}\n\n\t/**\n\t * This function (if available on the concrete control) provides the current accessibility state of the control.\n\t * @returns The accessibility information for the control.\n\t */\n\toverride getAccessibilityInfo(): AccessibilityInfo {\n\t\tlet accessibilityInfo = {};\n\t\tif (this.content?.isA<Control>(\"sap.ui.core.Control\") && this.content.getAccessibilityInfo) {\n\t\t\taccessibilityInfo = this.content.getAccessibilityInfo();\n\t\t}\n\t\treturn accessibilityInfo;\n\t}\n\n\t/**\n\t * Returns the DOMNode ID to be used for the \"labelFor\" attribute.\n\t *\n\t * We forward the call of this method to the content control.\n\t * @returns ID to be used for the <code>labelFor</code>\n\t */\n\toverride getIdForLabel(): string {\n\t\tif (this.content?.isA<Control>(\"sap.ui.core.Control\")) {\n\t\t\treturn this.content.getIdForLabel();\n\t\t}\n\t\treturn \"\";\n\t}\n\n\toverride addStyleClass(styleClass: string): this {\n\t\t(this.content as unknown as Control)?.addStyleClass(styleClass);\n\t\tsuper.addStyleClass(styleClass);\n\t\treturn this;\n\t}\n\n\toverride removeStyleClass(styleClass: string): this {\n\t\t(this.content as unknown as Control)?.removeStyleClass(styleClass);\n\t\tsuper.removeStyleClass(styleClass);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Shorthand for the BindingToolkit.bindState function with the current state object.\n\t * @param path A property in the state object\n\t * @returns The binding toolkit expression for the state\n\t * @public\n\t * @ui5-experimental-since 1.145.0\n\t */\n\tpublic bindState<ST extends PrimitiveType>(path: keyof K): BindingToolkitExpression<ST> {\n\t\treturn BindingToolkit.bindState(this.state as K, path);\n\t}\n\n\t/**\n\t * Synchronizes a state property with another building block's state property.\n\t * @param propName Name of the property in the current state object\n\t * @param source The source building block\n\t * @param property The property in the source building block's state object\n\t */\n\tpublic syncStateProperty(propName: string, source: BuildingBlockBase, property: string): void {\n\t\t(this.state as GenericState)[propName] = (source.state as GenericState)[property];\n\t\tconst propBinding = source.getModel(STATE_MODEL_NAME)?.bindProperty(\"/\" + property);\n\t\tpropBinding?.attachChange((): void => {\n\t\t\t(this.state as GenericState)[propName] = (source.state as GenericState)[property];\n\t\t});\n\t}\n\n\t/**\n\t * Framework hook for state change handling.\n\t * Subclasses can override this method to react to state changes.\n\t * @param _changedProps List of changed property names\n\t * @public\n\t * @ui5-experimental-since 1.145.0\n\t */\n\tprotected onStateChange(_changedProps: string[]): void;\n\n\tprotected async onStateChange(_changedProps: string[]): Promise<void> {}\n}\n\nexport default BuildingBlockBase;\n"],"mappings":";;;;;;;;;;;;;;;;;;EAaA;EAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EAPA,IASMA,iBAAiB,IAAAC,IAAA,GADtBC,cAAc,CAAC,+BAA+B,CAAC,EAAAC,KAAA,GAU9CC,WAAW,CAAC;IAAEC,IAAI,EAAE,qBAAqB;IAAEC,QAAQ,EAAE,KAAK;IAAEC,SAAS,EAAE;EAAK,CAAC,CAAC,EAAAC,KAAA,GAO9EC,WAAW,CAAC;IAAEJ,IAAI,EAAE,qBAAqB;IAAEC,QAAQ,EAAE,IAAI;IAAEI,YAAY,EAAE;EAAiB,CAAC,CAAC,EAAAC,KAAA,GAU5FC,WAAW,CAAC,CAAC,EAAAX,IAAA,CAAAY,MAAA,IAAAC,OAAA,0BAAAC,QAAA;IAKd,SAAAf,kBAAYgB,QAAsD,EAAEC,MAA2C,EAAEC,KAAc,EAAE;MAAA,IAAAC,KAAA;MAChI,IAAI,OAAOH,QAAQ,KAAK,QAAQ,EAAE;QACjCC,MAAM,KAAK,CAAC,CAAC;QACbA,MAAM,CAACG,EAAE,GAAGJ,QAAQ;MACrB;MACA;MACA;MACA;MACAG,KAAA,GAAAJ,QAAA,CAAAM,IAAA,OAAML,QAAQ,EAAuBC,MAAM,EAAEC,KAAK,CAAC;MAtCpD;AACD;AACA;AACA;AACA;AACA;AACA;AACA;MAPCI,0BAAA,CAAAH,KAAA,aAAAI,WAAA,EAAAJ,KAAA;MAWA;AACD;AACA;AACA;MAHCG,0BAAA,CAAAH,KAAA,oBAAAK,YAAA,EAAAL,KAAA;MAOA;AACD;AACA;AACA;AACA;AACA;AACA;MANCG,0BAAA,CAAAH,KAAA,WAAAM,YAAA,EAAAN,KAAA;MAAAA,KAAA,CAuBQO,UAAU,GAA4B,IAAI;MAAA,OAAAP,KAAA;IAFlD;IAACQ,cAAA,CAAA3B,iBAAA,EAAAe,QAAA;IAAA,IAAAa,MAAA,GAAA5B,iBAAA,CAAA6B,SAAA;IAAAD,MAAA,CAXDE,cAAc,GAAd,SAAAA,cAAcA,CAACC,GAAkB,EAAQ,CAAC,CAAC;IAAA/B,iBAAA,CAepCgC,MAAM,GAAb,SAAOA,MAAMA,CAAoBC,GAAkB,EAAEC,QAA8B,EAAQ;MAC1F,IAAI,CAACA,QAAQ,CAACC,OAAO,IAAID,QAAQ,CAACE,UAAU,CAAC,CAAC,KAAK,KAAK,EAAE;QACzD;QACAC,iBAAiB,CAACL,MAAM,CAACC,GAAG,EAAEC,QAAQ,CAAC;MACxC,CAAC,MAAM;QACNA,QAAQ,CAACJ,cAAc,GAAGG,GAAG,CAAC;QAC9BA,GAAG,CAACK,aAAa,CAACJ,QAAQ,CAACC,OAAO,CAAC;MACpC;IACD,CAAC;IAAAP,MAAA,CAEDW,iBAAiB,GAAjB,SAAAA,iBAAiBA,CAACC,OAAgB,EAAEC,KAAc,EAAQ;MACzD1B,QAAA,CAAAc,SAAA,CAAMU,iBAAiB,CAAAlB,IAAA,OAACmB,OAAO,EAAEC,KAAK;MACtC,IAAIA,KAAK,KAAKC,SAAS,IAAIF,OAAO,EAAE;QACnC,IAAI,CAACG,UAAU,CAAC,CAAC;MAClB;MACA,OAAO,IAAI;IACZ;;IAEA;AACD;AACA;AACA;AACA;AACA,OALC;IAAAf,MAAA,CAMSgB,YAAY,GAArB,SAASA,YAAYA,CAACC,IAAY,EAAEC,WAAgC,EAAQ;MAC3E,MAAMC,gBAAgB,GAAG,IAAI,CAACC,WAAW,CAAC,CAAC,CAACC,WAAW,CAACJ,IAAI,CAAC;MAC7D,IAAIE,gBAAgB,EAAEG,QAAQ,KAAK,KAAK,IAAIH,gBAAgB,CAACI,KAAK,KAAK,MAAM,EAAE;QAC7E,IAAI,CAA6BN,IAAI,CAAC,GAAGC,WAAW;MACtD,CAAC,MAAM;QACN/B,QAAA,CAAAc,SAAA,CAAMe,YAAY,CAAAvB,IAAA,OAACwB,IAAI,EAAEC,WAAW;MACrC;MACA,OAAO,IAAI;IACZ;;IAEA;AAAA;IAAAlB,MAAA,CACSwB,gBAAgB,GAAzB,SAASA,gBAAgBA,CAACC,KAAmB,EAAQ;MACpD,MAAMC,MAAM,GAAG,IAAI,CAACC,SAAS,CAAC,CAAC;MAC/B,IAAID,MAAM,EAAE;QACX,IAAI,CAAC5B,UAAU,GAAG,IAAI8B,OAAO,CAACF,MAAM,CAAC;MACtC,CAAC,MAAM;QACN,IAAI,CAAC5B,UAAU,GAAG,IAAI;MACvB;MACAX,QAAA,CAAAc,SAAA,CAAMuB,gBAAgB,CAAA/B,IAAA,OAACgC,KAAK;IAC7B,CAAC;IAAAzB,MAAA,CAEQ2B,SAAS,GAAlB,SAASA,SAASA,CAACE,MAAe,EAAkB;MACnD,MAAMC,QAAQ,GAAG,IAAI,CAACvB,OAAO;MAC7B,IAAImB,MAAsB,GAAGI,QAAQ,EAAEH,SAAS,CAACE,MAAM,CAAC,IAAA1C,QAAA,CAAAc,SAAA,CAAU0B,SAAS,CAAAlC,IAAA,OAACoC,MAAM,CAAC;MACnF,IAAI,CAACH,MAAM,IAAI,CAACG,MAAM,EAAE;QACvBH,MAAM,GAAG,IAAI,CAAC5B,UAAU,EAAEiC,KAAK,CAAC,CAAC,IAAI,IAAI;QACzC,IAAIL,MAAM,EAAE;UACX,OAAOM,QAAQ,CAACC,cAAc,CAACP,MAAM,CAAClC,EAAE,CAAC;QAC1C;MACD;MACA,OAAOkC,MAAM;IACd,CAAC;IAAA1B,MAAA,CAEQkC,cAAc,GAAvB,SAASA,cAAcA,CAAA,EAAmB;MACzC,MAAMJ,QAAQ,GAAG,IAAI,CAACvB,OAAO;MAC7B,OAAOuB,QAAQ,GAAGA,QAAQ,CAACI,cAAc,CAAC,CAAC,GAAA/C,QAAA,CAAAc,SAAA,CAASiC,cAAc,CAAAzC,IAAA,MAAE;IACrE;;IAEA;AACD;AACA;AACA;AACA;AACA,OALC;IAAAO,MAAA,CAMSmC,yBAAyB,GAAlC,SAASA,yBAAyBA,CAACC,SAAiB,EAAEC,UAAkB,EAAU;MACjF,MAAMC,OAAO,GAAG,IAAI,CAACC,SAAS,CAAC,CAAC;MAEhC,IAAID,OAAO,IAAKA,OAAO,CAA8DH,yBAAyB,EAAE;QAC/G;QACCG,OAAO,CAA6DH,yBAAyB,CAACC,SAAS,EAAEC,UAAU,CAAC;MACtH;MAEA,OAAOA,UAAU;IAClB;;IAEA;AACD;AACA;AACA,OAHC;IAAArC,MAAA,CAISwC,oBAAoB,GAA7B,SAASA,oBAAoBA,CAAA,EAAsB;MAClD,IAAIC,iBAAiB,GAAG,CAAC,CAAC;MAC1B,IAAI,IAAI,CAAClC,OAAO,EAAEmC,GAAG,CAAU,qBAAqB,CAAC,IAAI,IAAI,CAACnC,OAAO,CAACiC,oBAAoB,EAAE;QAC3FC,iBAAiB,GAAG,IAAI,CAAClC,OAAO,CAACiC,oBAAoB,CAAC,CAAC;MACxD;MACA,OAAOC,iBAAiB;IACzB;;IAEA;AACD;AACA;AACA;AACA;AACA,OALC;IAAAzC,MAAA,CAMS2C,aAAa,GAAtB,SAASA,aAAaA,CAAA,EAAW;MAChC,IAAI,IAAI,CAACpC,OAAO,EAAEmC,GAAG,CAAU,qBAAqB,CAAC,EAAE;QACtD,OAAO,IAAI,CAACnC,OAAO,CAACoC,aAAa,CAAC,CAAC;MACpC;MACA,OAAO,EAAE;IACV,CAAC;IAAA3C,MAAA,CAEQ4C,aAAa,GAAtB,SAASA,aAAaA,CAACC,UAAkB,EAAQ;MAC/C,IAAI,CAACtC,OAAO,EAAyBqC,aAAa,CAACC,UAAU,CAAC;MAC/D1D,QAAA,CAAAc,SAAA,CAAM2C,aAAa,CAAAnD,IAAA,OAACoD,UAAU;MAC9B,OAAO,IAAI;IACZ,CAAC;IAAA7C,MAAA,CAEQ8C,gBAAgB,GAAzB,SAASA,gBAAgBA,CAACD,UAAkB,EAAQ;MAClD,IAAI,CAACtC,OAAO,EAAyBuC,gBAAgB,CAACD,UAAU,CAAC;MAClE1D,QAAA,CAAAc,SAAA,CAAM6C,gBAAgB,CAAArD,IAAA,OAACoD,UAAU;MACjC,OAAO,IAAI;IACZ;;IAEA;AACD;AACA;AACA;AACA;AACA;AACA,OANC;IAAA7C,MAAA,CAOO+C,SAAS,GAAhB,SAAOA,SAASA,CAA2BC,IAAa,EAAgC;MACvF,OAAOC,cAAc,CAACF,SAAS,CAAC,IAAI,CAACG,KAAK,EAAOF,IAAI,CAAC;IACvD;;IAEA;AACD;AACA;AACA;AACA;AACA,OALC;IAAAhD,MAAA,CAMOmD,iBAAiB,GAAxB,SAAOA,iBAAiBA,CAACC,QAAgB,EAAEC,MAAyB,EAAEC,QAAgB,EAAQ;MAC5F,IAAI,CAACJ,KAAK,CAAkBE,QAAQ,CAAC,GAAIC,MAAM,CAACH,KAAK,CAAkBI,QAAQ,CAAC;MACjF,MAAMC,WAAW,GAAGF,MAAM,CAACG,QAAQ,CAACC,gBAAgB,CAAC,EAAEzC,YAAY,CAAC,GAAG,GAAGsC,QAAQ,CAAC;MACnFC,WAAW,EAAEG,YAAY,CAAC,MAAY;QACpC,IAAI,CAACR,KAAK,CAAkBE,QAAQ,CAAC,GAAIC,MAAM,CAACH,KAAK,CAAkBI,QAAQ,CAAC;MAClF,CAAC,CAAC;IACH;;IAEA;AACD;AACA;AACA;AACA;AACA;AACA,OANC;IAAAtD,MAAA,CASgB2D,aAAa,GAA7B,eAAgBA,aAAaA,CAACC,aAAuB,EAAiB,CAAC,CAAC;IAAA,OAAAxF,iBAAA;EAAA,EAlMcyF,OAAO,GAAAlE,WAAA,GAAAmE,yBAAA,CAAA5E,OAAA,CAAAe,SAAA,cAAA1B,KAAA;IAAAwF,YAAA;IAAAC,UAAA;IAAAC,QAAA;IAAAC,WAAA;EAAA,IAAAtE,YAAA,GAAAkE,yBAAA,CAAA5E,OAAA,CAAAe,SAAA,qBAAArB,KAAA;IAAAmF,YAAA;IAAAC,UAAA;IAAAC,QAAA;IAAAC,WAAA;EAAA,IAAArE,YAAA,GAAAiE,yBAAA,CAAA5E,OAAA,CAAAe,SAAA,YAAAlB,KAAA;IAAAgF,YAAA;IAAAC,UAAA;IAAAC,QAAA;IAAAC,WAAA;EAAA,IAAAhF,OAAA,MAAAD,MAAA;EAAA,OAqM/Eb,iBAAiB;AAAA","ignoreList":[]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["BuildingBlockBase","_dec","defineUI5Class","_dec2","aggregation","type","multiple","isDefault","_dec3","association","singularName","_dec4","defineState","_class","_class2","_Control","settings","others","scope","_this","id","call","_initializerDefineProperty","_descriptor","_descriptor2","_descriptor3","_oldDomRef","_inheritsLoose","_proto","prototype","getPlaceholder","_rm","render","oRm","oControl","content","getVisible","InvisibleRenderer","renderControl","setBindingContext","context","model","undefined","invalidate","bindProperty","name","bindingInfo","propertyMetadata","getMetadata","getProperty","bindable","group","onAfterRendering","event","domRef","getDomRef","WeakRef","suffix","oContent","deref","document","getElementById","getFocusDomRef","enhanceAccessibilityState","_oElement","mAriaProps","oParent","getParent","getAccessibilityInfo","isA","getIdForLabel","addStyleClass","styleClass","removeStyleClass","bindState","path","BindingToolkit","state","syncStateProperty","propName","source","property","propBinding","getModel","STATE_MODEL_NAME","attachChange","onStateChange","_changedProps","Control","_applyDecoratedDescriptor","configurable","enumerable","writable","initializer"],"sourceRoot":".","sources":["BuildingBlockBase.ts"],"sourcesContent":["import type { BindingToolkitExpression, PrimitiveType } from \"sap/fe/base/BindingToolkit\";\nimport * as BindingToolkit from \"sap/fe/base/BindingToolkit\";\nimport type { GenericState, PropertiesOf, StateOf } from \"sap/fe/base/ClassSupport\";\nimport { aggregation, association, defineState, defineUI5Class, STATE_MODEL_NAME } from \"sap/fe/base/ClassSupport\";\nimport type ManagedObject from \"sap/ui/base/ManagedObject\";\nimport type { PropertyBindingInfo } from \"sap/ui/base/ManagedObject\";\nimport Control from \"sap/ui/core/Control\";\nimport type UI5Element from \"sap/ui/core/Element\";\nimport InvisibleRenderer from \"sap/ui/core/InvisibleRenderer\";\nimport type RenderManager from \"sap/ui/core/RenderManager\";\nimport type { AccessibilityInfo } from \"sap/ui/core/library\";\nimport type Context from \"sap/ui/model/Context\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ninterface BuildingBlockBase<T extends UI5Element = Control, K extends object = {}> {\n\t// Force a state update\n\t_updateState(): Promise<void>;\n}\n\n/**\n * Base class for building blocks.\n * This contains the low-level functionality of having a content aggregation and handling the rendering of the content without an actual DOM element.<br/>\n * The building block also defines a state object that can be used to store the state of the building block.<br/>\n * Accessibility and classes information are forwarded to the content control.<br/>\n * This class is not meant to be used directly, it's there for internal use only (and documentation)\n * @public\n */\n@defineUI5Class(\"sap.fe.base.BuildingBlockBase\")\nclass BuildingBlockBase<T extends UI5Element = Control, K extends object = {}> extends Control {\n\t/**\n\t * Optional content of generic type T.\n\t *\n\t * This property holds the main data or payload for the containing object.\n\t * When undefined, it indicates that no content has been set or is available.\n\t * The specific type and structure of the content depends on the generic type parameter T.\n\t * @public\n\t */\n\t@aggregation({ type: \"sap.ui.core.Element\", multiple: false, isDefault: true })\n\tcontent?: T;\n\n\t/**\n\t * Association to controls / IDs that label this control (see WAI-ARIA attribute aria-labelledby).\n\t * @public\n\t */\n\t@association({ type: \"sap.ui.core.Control\", multiple: true, singularName: \"ariaLabelledBy\" })\n\tariaLabelledBy!: string[];\n\n\t/**\n\t * The current state value of the component.\n\t *\n\t * This property holds the state data managed by the component, with the type\n\t * determined by the generic parameter K.\n\t * @public\n\t */\n\t@defineState()\n\tprotected state!: StateOf<K>;\n\n\tgetPlaceholder(_rm: RenderManager): void {}\n\n\tconstructor(settings?: string | PropertiesOf<BuildingBlockBase<T>>, others?: PropertiesOf<BuildingBlockBase<T>>, scope?: object) {\n\t\tif (typeof settings === \"string\") {\n\t\t\tothers ??= {};\n\t\t\tothers.id = settings;\n\t\t}\n\t\t// Scope is defined and is there, but somehow doesn't appear on all the children of ManagedObject\n\t\t// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n\t\t// @ts-ignore\n\t\tsuper(settings as unknown as string, others, scope);\n\t}\n\n\tprivate _oldDomRef: WeakRef<Element> | null = null;\n\n\tstatic render<T extends Control>(oRm: RenderManager, oControl: BuildingBlockBase<T>): void {\n\t\tif (!oControl.content || oControl.getVisible() === false) {\n\t\t\t// If there is no content, we render an invisible renderer to avoid the control being\n\t\t\tInvisibleRenderer.render(oRm, oControl);\n\t\t} else {\n\t\t\toControl.getPlaceholder?.(oRm);\n\t\t\toRm.renderControl(oControl.content);\n\t\t}\n\t}\n\n\tsetBindingContext(context: Context, model?: string): this {\n\t\tsuper.setBindingContext(context, model);\n\t\tif (model === undefined && context) {\n\t\t\tthis.invalidate();\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Override the bindProperty to deal with the case where the property is a binding info.\n\t * @param name The name of te property\n\t * @param bindingInfo The binding info\n\t * @returns The instance of the building block for chaining\n\t */\n\toverride bindProperty(name: string, bindingInfo: PropertyBindingInfo): this {\n\t\tconst propertyMetadata = this.getMetadata().getProperty(name);\n\t\tif (propertyMetadata?.bindable === false && propertyMetadata.group === \"Data\") {\n\t\t\t(this as Record<string, unknown>)[name] = bindingInfo;\n\t\t} else {\n\t\t\tsuper.bindProperty(name, bindingInfo);\n\t\t}\n\t\treturn this;\n\t}\n\n\t//set the old dom ref\n\toverride onAfterRendering(event: JQuery.Event): void {\n\t\tconst domRef = this.getDomRef();\n\t\tif (domRef) {\n\t\t\tthis._oldDomRef = new WeakRef(domRef);\n\t\t} else {\n\t\t\tthis._oldDomRef = null;\n\t\t}\n\t\tsuper.onAfterRendering(event);\n\t}\n\n\toverride getDomRef(suffix?: string): Element | null {\n\t\tconst oContent = this.content;\n\t\tlet domRef: Element | null = oContent?.getDomRef(suffix) ?? super.getDomRef(suffix);\n\t\tif (!domRef && !suffix) {\n\t\t\tdomRef = this._oldDomRef?.deref() ?? null;\n\t\t\tif (domRef) {\n\t\t\t\treturn document.getElementById(domRef.id);\n\t\t\t}\n\t\t}\n\t\treturn domRef;\n\t}\n\n\toverride getFocusDomRef(): Element | null {\n\t\tconst oContent = this.content;\n\t\treturn oContent ? oContent.getFocusDomRef() : super.getFocusDomRef();\n\t}\n\n\t/**\n\t * This function asks up the control tree to enhance the accessibility state of the control.\n\t * @param _oElement The element to enhance\n\t * @param mAriaProps The current aria properties\n\t * @returns The enhanced aria properties\n\t */\n\toverride enhanceAccessibilityState(_oElement: object, mAriaProps: object): object {\n\t\tconst oParent = this.getParent();\n\n\t\tif (oParent && (oParent as ManagedObject & { enhanceAccessibilityState?: Function }).enhanceAccessibilityState) {\n\t\t\t// forward  enhanceAccessibilityState call to the parent\n\t\t\t(oParent as ManagedObject & { enhanceAccessibilityState: Function }).enhanceAccessibilityState(_oElement, mAriaProps);\n\t\t}\n\n\t\treturn mAriaProps;\n\t}\n\n\t/**\n\t * This function (if available on the concrete control) provides the current accessibility state of the control.\n\t * When the content control is not visible, null is returned so that sap.m.Table can set aria-label=\"\"\n\t * on the gridcell, preventing screen reader virtual buffer bleed-through (ACC-264.1 / WCAG 2.1 Level A).\n\t * @returns The accessibility information for the control, or null (cast) when content is not visible.\n\t */\n\toverride getAccessibilityInfo(): AccessibilityInfo {\n\t\tif (this.content?.isA<Control>(\"sap.ui.core.Control\") && this.content.getAccessibilityInfo) {\n\t\t\tif (!this.content.getVisible()) {\n\t\t\t\t// Content is not visible: return null (cast to preserve the type contract) so that\n\t\t\t\t// sap.m.Table receives a falsy value and sets aria-label=\"\" on the gridcell,\n\t\t\t\t// preventing screen reader virtual buffer bleed-through (ACC-264.1 / WCAG 2.1 Level A).\n\t\t\t\treturn null as unknown as AccessibilityInfo;\n\t\t\t}\n\t\t\treturn this.content.getAccessibilityInfo();\n\t\t}\n\t\treturn {};\n\t}\n\n\t/**\n\t * Returns the DOMNode ID to be used for the \"labelFor\" attribute.\n\t *\n\t * We forward the call of this method to the content control.\n\t * @returns ID to be used for the <code>labelFor</code>\n\t */\n\toverride getIdForLabel(): string {\n\t\tif (this.content?.isA<Control>(\"sap.ui.core.Control\")) {\n\t\t\treturn this.content.getIdForLabel();\n\t\t}\n\t\treturn \"\";\n\t}\n\n\toverride addStyleClass(styleClass: string): this {\n\t\t(this.content as unknown as Control)?.addStyleClass(styleClass);\n\t\tsuper.addStyleClass(styleClass);\n\t\treturn this;\n\t}\n\n\toverride removeStyleClass(styleClass: string): this {\n\t\t(this.content as unknown as Control)?.removeStyleClass(styleClass);\n\t\tsuper.removeStyleClass(styleClass);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Shorthand for the BindingToolkit.bindState function with the current state object.\n\t * @param path A property in the state object\n\t * @returns The binding toolkit expression for the state\n\t */\n\tpublic bindState<ST extends PrimitiveType>(path: keyof K): BindingToolkitExpression<ST> {\n\t\treturn BindingToolkit.bindState(this.state as K, path);\n\t}\n\n\t/**\n\t * Synchronizes a state property with another building block's state property.\n\t * @param propName Name of the property in the current state object\n\t * @param source The source building block\n\t * @param property The property in the source building block's state object\n\t */\n\tpublic syncStateProperty(propName: string, source: BuildingBlockBase, property: string): void {\n\t\t(this.state as GenericState)[propName] = (source.state as GenericState)[property];\n\t\tconst propBinding = source.getModel(STATE_MODEL_NAME)?.bindProperty(\"/\" + property);\n\t\tpropBinding?.attachChange((): void => {\n\t\t\t(this.state as GenericState)[propName] = (source.state as GenericState)[property];\n\t\t});\n\t}\n\n\t/**\n\t * Framework hook for state change handling.\n\t * Subclasses can override this method to react to state changes.\n\t * @param _changedProps List of changed property names\n\t */\n\tprotected onStateChange(_changedProps: string[]): void;\n\n\tprotected async onStateChange(_changedProps: string[]): Promise<void> {}\n}\n\nexport default BuildingBlockBase;\n"],"mappings":"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","ignoreList":[]}

package/src/sap/fe/base/BuildingBlockBase.ts

@@ -151,14 +151,21 @@ class BuildingBlockBase<T extends UI5Element = Control, K extends object = {}> e
 
 	/**
 	 * This function (if available on the concrete control) provides the current accessibility state of the control.
-	 * @returns The accessibility information for the control.
+	 * When the content control is not visible, null is returned so that sap.m.Table can set aria-label=""
+	 * on the gridcell, preventing screen reader virtual buffer bleed-through (ACC-264.1 / WCAG 2.1 Level A).
+	 * @returns The accessibility information for the control, or null (cast) when content is not visible.
 	 */
 	override getAccessibilityInfo(): AccessibilityInfo {
-		let accessibilityInfo = {};
 		if (this.content?.isA<Control>("sap.ui.core.Control") && this.content.getAccessibilityInfo) {
-			accessibilityInfo = this.content.getAccessibilityInfo();
+			if (!this.content.getVisible()) {
+				// Content is not visible: return null (cast to preserve the type contract) so that
+				// sap.m.Table receives a falsy value and sets aria-label="" on the gridcell,
+				// preventing screen reader virtual buffer bleed-through (ACC-264.1 / WCAG 2.1 Level A).
+				return null as unknown as AccessibilityInfo;
+			}
+			return this.content.getAccessibilityInfo();
 		}
-		return accessibilityInfo;
+		return {};
 	}
 
 	/**
@@ -190,8 +197,6 @@ class BuildingBlockBase<T extends UI5Element = Control, K extends object = {}> e
 	 * Shorthand for the BindingToolkit.bindState function with the current state object.
 	 * @param path A property in the state object
 	 * @returns The binding toolkit expression for the state
-	 * @public
-	 * @ui5-experimental-since 1.145.0
 	 */
 	public bindState<ST extends PrimitiveType>(path: keyof K): BindingToolkitExpression<ST> {
 		return BindingToolkit.bindState(this.state as K, path);
@@ -215,8 +220,6 @@ class BuildingBlockBase<T extends UI5Element = Control, K extends object = {}> e
 	 * Framework hook for state change handling.
 	 * Subclasses can override this method to react to state changes.
 	 * @param _changedProps List of changed property names
-	 * @public
-	 * @ui5-experimental-since 1.145.0
 	 */
 	protected onStateChange(_changedProps: string[]): void;