@nativescript/core 9.0.0-next-07-26-2025-16544379102 → 9.0.0-preview.1

package/ui/list-view/index.d.ts

@@ -2,7 +2,7 @@
 import { Color } from '../../color';
 import { CoreTypes } from '../../core-types';
 import { EventData } from '../../data/observable';
-import { Length } from '../styling/style-properties';
+import { Length } from '../styling/length-shared';
 import { Style } from '../styling/style';
 import { Property, CssProperty } from '../core/properties';
 
@@ -99,6 +99,46 @@ export class ListView extends View {
 	 */
 	iosEstimatedRowHeight: CoreTypes.LengthType;
 
+	/**
+	 * Gets or sets a value indicating whether the ListView should display sticky headers.
+	 * When enabled, headers will remain visible at the top while scrolling through sections.
+	 *
+	 * @nsProperty
+	 */
+	stickyHeader: boolean;
+
+	/**
+	 * Gets or sets the template for sticky headers.
+	 *
+	 * @nsProperty
+	 */
+	stickyHeaderTemplate: string | Template;
+
+	/**
+	 * Gets or sets the height of sticky headers.
+	 *
+	 * @nsProperty
+	 */
+	stickyHeaderHeight: CoreTypes.LengthType;
+
+	/**
+	 * Gets or sets a value indicating whether the ListView should show default top padding above section headers.
+	 * When set to false (default), removes iOS default spacing for a tighter layout.
+	 * When set to true, preserves iOS default ~4-5px spacing above section headers.
+	 *
+	 * @nsProperty
+	 */
+	stickyHeaderTopPadding: boolean;
+
+	/**
+	 * Gets or sets a value indicating whether the ListView should treat items as sectioned data.
+	 * When enabled, items array should contain objects with 'items' property for section content.
+	 * Each section will have its own sticky header.
+	 *
+	 * @nsProperty
+	 */
+	sectioned: boolean;
+
 	/**
 	 * Forces the ListView to reload all its items.
 	 */
@@ -230,3 +270,28 @@ export const iosEstimatedRowHeightProperty: Property<ListView, CoreTypes.LengthT
  * Backing property for separator color property.
  */
 export const separatorColorProperty: CssProperty<Style, Color>;
+
+/**
+ * Represents the observable property backing the stickyHeader property of each ListView instance.
+ */
+export const stickyHeaderProperty: Property<ListView, boolean>;
+
+/**
+ * Represents the sticky header template property of each ListView instance.
+ */
+export const stickyHeaderTemplateProperty: Property<ListView, string | Template>;
+
+/**
+ * Represents the observable property backing the stickyHeaderHeight property of each ListView instance.
+ */
+export const stickyHeaderHeightProperty: Property<ListView, CoreTypes.LengthType>;
+
+/**
+ * Represents the observable property backing the stickyHeaderTopPadding property of each ListView instance.
+ */
+export const stickyHeaderTopPaddingProperty: Property<ListView, boolean>;
+
+/**
+ * Represents the observable property backing the sectioned property of each ListView instance.
+ */
+export const sectionedProperty: Property<ListView, boolean>;

package/ui/list-view/index.ios.d.ts

@@ -1,6 +1,6 @@
-import { ListViewBase, separatorColorProperty, itemTemplatesProperty, iosEstimatedRowHeightProperty } from './list-view-common';
+import { ListViewBase, separatorColorProperty, itemTemplatesProperty, iosEstimatedRowHeightProperty, stickyHeaderProperty, stickyHeaderTemplateProperty, stickyHeaderHeightProperty, sectionedProperty } from './list-view-common';
 import { CoreTypes } from '../../core-types';
-import { View, KeyedTemplate } from '../core/view';
+import { View, KeyedTemplate, Template } from '../core/view';
 import { Color } from '../../color';
 export * from './list-view-common';
 declare class ListViewCell extends UITableViewCell {
@@ -10,6 +10,13 @@ declare class ListViewCell extends UITableViewCell {
     get view(): View;
     owner: WeakRef<View>;
 }
+declare class ListViewHeaderCell extends UITableViewHeaderFooterView {
+    static initWithEmptyBackground(): ListViewHeaderCell;
+    initWithReuseIdentifier(reuseIdentifier: string): this;
+    willMoveToSuperview(newSuperview: UIView): void;
+    get view(): View;
+    owner: WeakRef<View>;
+}
 export declare class ListView extends ListViewBase {
     [separatorColorProperty.getDefault]: () => UIColor;
     [separatorColorProperty.setNative]: (value: Color | UIColor) => void;
@@ -17,6 +24,14 @@ export declare class ListView extends ListViewBase {
     [itemTemplatesProperty.setNative]: (value: KeyedTemplate[]) => void;
     [iosEstimatedRowHeightProperty.getDefault]: () => CoreTypes.LengthType;
     [iosEstimatedRowHeightProperty.setNative]: (value: CoreTypes.LengthType) => void;
+    [stickyHeaderProperty.getDefault]: () => boolean;
+    [stickyHeaderProperty.setNative]: (value: boolean) => void;
+    [stickyHeaderTemplateProperty.getDefault]: () => string | Template;
+    [stickyHeaderTemplateProperty.setNative]: (value: string | Template) => void;
+    [stickyHeaderHeightProperty.getDefault]: () => CoreTypes.LengthType;
+    [stickyHeaderHeightProperty.setNative]: (value: CoreTypes.LengthType) => void;
+    [sectionedProperty.getDefault]: () => boolean;
+    [sectionedProperty.setNative]: (value: boolean) => void;
     nativeViewProtected: UITableView;
     private _dataSource;
     private _delegate;
@@ -24,6 +39,9 @@ export declare class ListView extends ListViewBase {
     private _preparingCell;
     private _isDataDirty;
     private _map;
+    private _headerMap;
+    private _preparingHeader;
+    private _headerTemplateCache;
     widthMeasureSpec: number;
     constructor();
     createNativeView(): UITableView;
@@ -49,4 +67,8 @@ export declare class ListView extends ListViewBase {
     private _layoutCell;
     _prepareCell(cell: ListViewCell, indexPath: NSIndexPath): number;
     _removeContainer(cell: ListViewCell): void;
+    _prepareHeader(headerCell: ListViewHeaderCell, section: number): number;
+    private _layoutHeader;
+    private _getHeaderTemplate;
+    _removeHeaderContainer(headerCell: ListViewHeaderCell): void;
 }

package/ui/list-view/index.ios.js

@@ -1,6 +1,6 @@
-import { ListViewBase, separatorColorProperty, itemTemplatesProperty, iosEstimatedRowHeightProperty } from './list-view-common';
+import { ListViewBase, separatorColorProperty, itemTemplatesProperty, iosEstimatedRowHeightProperty, stickyHeaderProperty, stickyHeaderTemplateProperty, stickyHeaderHeightProperty, sectionedProperty } from './list-view-common';
 import { View } from '../core/view';
-import { Length } from '../styling/style-properties';
+import { Length } from '../styling/length-shared';
 import { Observable } from '../../data/observable';
 import { Color } from '../../color';
 import { layout } from '../../utils';
@@ -8,6 +8,9 @@ import { StackLayout } from '../layouts/stack-layout';
 import { ProxyViewContainer } from '../proxy-view-container';
 import { profile } from '../../profiling';
 import { Trace } from '../../trace';
+import { Builder } from '../builder';
+import { Label } from '../label';
+import { isFunction } from '../../utils/types';
 export * from './list-view-common';
 const ITEMLOADING = ListViewBase.itemLoadingEvent;
 const LOADMOREITEMS = ListViewBase.loadMoreItemsEvent;
@@ -48,6 +51,40 @@ var ListViewCell = /** @class */ (function (_super) {
     });
     return ListViewCell;
 }(UITableViewCell));
+var ListViewHeaderCell = /** @class */ (function (_super) {
+    __extends(ListViewHeaderCell, _super);
+    function ListViewHeaderCell() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ListViewHeaderCell.initWithEmptyBackground = function () {
+        var cell = ListViewHeaderCell.new();
+        // Clear background by default - this will make headers transparent
+        cell.backgroundColor = UIColor.clearColor;
+        return cell;
+    };
+    ListViewHeaderCell.prototype.initWithReuseIdentifier = function (reuseIdentifier) {
+        var cell = _super.prototype.initWithReuseIdentifier.call(this, reuseIdentifier);
+        // Clear background by default - this will make headers transparent
+        cell.backgroundColor = UIColor.clearColor;
+        return cell;
+    };
+    ListViewHeaderCell.prototype.willMoveToSuperview = function (newSuperview) {
+        var parent = (this.view ? this.view.parent : null);
+        // When inside ListView and there is no newSuperview this header is
+        // removed from native visual tree so we remove it from our tree too.
+        if (parent && !newSuperview) {
+            parent._removeHeaderContainer(this);
+        }
+    };
+    Object.defineProperty(ListViewHeaderCell.prototype, "view", {
+        get: function () {
+            return this.owner ? this.owner.deref() : null;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return ListViewHeaderCell;
+}(UITableViewHeaderFooterView));
 function notifyForItemAtIndex(listView, cell, view, eventName, indexPath) {
     const args = {
         eventName: eventName,
@@ -70,10 +107,30 @@ var DataSource = /** @class */ (function (_super) {
         dataSource._owner = owner;
         return dataSource;
     };
+    DataSource.prototype.numberOfSectionsInTableView = function (tableView) {
+        var _a;
+        var owner = (_a = this._owner) === null || _a === void 0 ? void 0 : _a.deref();
+        if (!owner) {
+            return 1;
+        }
+        var sections = owner._getSectionCount();
+        if (Trace.isEnabled()) {
+            Trace.write("ListView: numberOfSections = ".concat(sections, " (sectioned: ").concat(owner.sectioned, ")"), Trace.categories.Debug);
+        }
+        return sections;
+    };
     DataSource.prototype.tableViewNumberOfRowsInSection = function (tableView, section) {
         var _a;
         var owner = (_a = this._owner) === null || _a === void 0 ? void 0 : _a.deref();
-        return owner && owner.items ? owner.items.length : 0;
+        if (!owner) {
+            return 0;
+        }
+        var sectionItems = owner._getItemsInSection(section);
+        var rowCount = sectionItems ? sectionItems.length : 0;
+        if (Trace.isEnabled()) {
+            Trace.write("ListView: numberOfRows in section ".concat(section, " = ").concat(rowCount), Trace.categories.Debug);
+        }
+        return rowCount;
     };
     DataSource.prototype.tableViewCellForRowAtIndexPath = function (tableView, indexPath) {
         var _a;
@@ -156,6 +213,46 @@ var UITableViewDelegateImpl = /** @class */ (function (_super) {
         }
         return layout.toDeviceIndependentPixels(height);
     };
+    UITableViewDelegateImpl.prototype.tableViewViewForHeaderInSection = function (tableView, section) {
+        var _a;
+        var owner = (_a = this._owner) === null || _a === void 0 ? void 0 : _a.deref();
+        if (!owner || !owner.stickyHeader || !owner.stickyHeaderTemplate) {
+            if (Trace.isEnabled()) {
+                Trace.write("ListView: No sticky header (stickyHeader: ".concat(owner === null || owner === void 0 ? void 0 : owner.stickyHeader, ", hasTemplate: ").concat(!!(owner === null || owner === void 0 ? void 0 : owner.stickyHeaderTemplate), ")"), Trace.categories.Debug);
+            }
+            return null;
+        }
+        if (Trace.isEnabled()) {
+            Trace.write("ListView: Creating sticky header", Trace.categories.Debug);
+        }
+        var headerReuseIdentifier = 'stickyHeader';
+        var headerCell = tableView.dequeueReusableHeaderFooterViewWithIdentifier(headerReuseIdentifier);
+        if (!headerCell) {
+            // Use proper iOS initialization for registered header cells
+            headerCell = ListViewHeaderCell.alloc().initWithReuseIdentifier(headerReuseIdentifier);
+            headerCell.backgroundColor = UIColor.clearColor;
+        }
+        owner._prepareHeader(headerCell, section);
+        return headerCell;
+    };
+    UITableViewDelegateImpl.prototype.tableViewHeightForHeaderInSection = function (tableView, section) {
+        var _a;
+        var owner = (_a = this._owner) === null || _a === void 0 ? void 0 : _a.deref();
+        if (!owner || !owner.stickyHeader) {
+            return 0;
+        }
+        var height;
+        if (owner.stickyHeaderHeight === 'auto') {
+            height = 44;
+        }
+        else {
+            height = layout.toDeviceIndependentPixels(Length.toDevicePixels(owner.stickyHeaderHeight, 44));
+        }
+        if (Trace.isEnabled()) {
+            Trace.write("ListView: Sticky header height: ".concat(height), Trace.categories.Debug);
+        }
+        return height;
+    };
     UITableViewDelegateImpl.ObjCProtocols = [UITableViewDelegate];
     return UITableViewDelegateImpl;
 }(NSObject));
@@ -200,6 +297,45 @@ var UITableViewRowHeightDelegateImpl = /** @class */ (function (_super) {
         }
         return layout.toDeviceIndependentPixels(owner._effectiveRowHeight);
     };
+    UITableViewRowHeightDelegateImpl.prototype.tableViewViewForHeaderInSection = function (tableView, section) {
+        var _a;
+        var owner = (_a = this._owner) === null || _a === void 0 ? void 0 : _a.deref();
+        if (!owner || !owner.stickyHeader || !owner.stickyHeaderTemplate) {
+            if (Trace.isEnabled()) {
+                Trace.write("ListView: No sticky header (stickyHeader: ".concat(owner === null || owner === void 0 ? void 0 : owner.stickyHeader, ", hasTemplate: ").concat(!!(owner === null || owner === void 0 ? void 0 : owner.stickyHeaderTemplate), ")"), Trace.categories.Debug);
+            }
+            return null;
+        }
+        if (Trace.isEnabled()) {
+            Trace.write("ListView: Creating sticky header", Trace.categories.Debug);
+        }
+        var headerReuseIdentifier = 'stickyHeader';
+        var headerCell = tableView.dequeueReusableHeaderFooterViewWithIdentifier(headerReuseIdentifier);
+        if (!headerCell) {
+            headerCell = ListViewHeaderCell.alloc().initWithReuseIdentifier(headerReuseIdentifier);
+            headerCell.backgroundColor = UIColor.clearColor;
+        }
+        owner._prepareHeader(headerCell, section);
+        return headerCell;
+    };
+    UITableViewRowHeightDelegateImpl.prototype.tableViewHeightForHeaderInSection = function (tableView, section) {
+        var _a;
+        var owner = (_a = this._owner) === null || _a === void 0 ? void 0 : _a.deref();
+        if (!owner || !owner.stickyHeader) {
+            return 0;
+        }
+        var height;
+        if (owner.stickyHeaderHeight === 'auto') {
+            height = 44;
+        }
+        else {
+            height = layout.toDeviceIndependentPixels(Length.toDevicePixels(owner.stickyHeaderHeight, 44));
+        }
+        if (Trace.isEnabled()) {
+            Trace.write("ListView: Sticky header height: ".concat(height), Trace.categories.Debug);
+        }
+        return height;
+    };
     UITableViewRowHeightDelegateImpl.ObjCProtocols = [UITableViewDelegate];
     return UITableViewRowHeightDelegateImpl;
 }(NSObject));
@@ -208,6 +344,7 @@ export class ListView extends ListViewBase {
         super();
         this.widthMeasureSpec = 0;
         this._map = new Map();
+        this._headerMap = new Map();
         this._heights = new Array();
     }
     createNativeView() {
@@ -217,10 +354,18 @@ export class ListView extends ListViewBase {
         super.initNativeView();
         const nativeView = this.nativeViewProtected;
         nativeView.registerClassForCellReuseIdentifier(ListViewCell.class(), this._defaultTemplate.key);
+        nativeView.registerClassForHeaderFooterViewReuseIdentifier(ListViewHeaderCell.class(), 'stickyHeader');
         nativeView.estimatedRowHeight = DEFAULT_HEIGHT;
         nativeView.rowHeight = UITableViewAutomaticDimension;
         nativeView.dataSource = this._dataSource = DataSource.initWithOwner(new WeakRef(this));
         this._delegate = UITableViewDelegateImpl.initWithOwner(new WeakRef(this));
+        // Control section header top padding (iOS 15+)
+        if (nativeView.respondsToSelector('setSectionHeaderTopPadding:')) {
+            if (!this.stickyHeaderTopPadding) {
+                nativeView.sectionHeaderTopPadding = 0;
+            }
+            // When stickyHeaderTopPadding is true, don't set the property to use iOS default
+        }
         this._setNativeClipToBounds();
     }
     disposeNativeView() {
@@ -247,12 +392,15 @@ export class ListView extends ListViewBase {
         return this.nativeViewProtected;
     }
     get _childrenCount() {
-        return this._map.size;
+        return this._map.size + this._headerMap.size;
     }
     eachChildView(callback) {
         this._map.forEach((view, key) => {
             callback(view);
         });
+        this._headerMap.forEach((view, key) => {
+            callback(view);
+        });
     }
     scrollToIndex(index) {
         this._scrollToIndex(index, false);
@@ -286,6 +434,11 @@ export class ListView extends ListViewBase {
                 view.bindingContext = null;
             }
         });
+        this._headerMap.forEach((view, nativeView, map) => {
+            if (!(view.bindingContext instanceof Observable)) {
+                view.bindingContext = null;
+            }
+        });
         if (this.isLoaded) {
             this.nativeViewProtected.reloadData();
             this.requestLayout();
@@ -324,8 +477,8 @@ export class ListView extends ListViewBase {
         super._onRowHeightPropertyChanged(oldValue, newValue);
     }
     requestLayout() {
-        // When preparing cell don't call super - no need to invalidate our measure when cell desiredSize is changed.
-        if (!this._preparingCell) {
+        // When preparing cell or header don't call super - no need to invalidate our measure when cell/header desiredSize is changed.
+        if (!this._preparingCell && !this._preparingHeader) {
             super.requestLayout();
         }
     }
@@ -343,6 +496,9 @@ export class ListView extends ListViewBase {
         this._map.forEach((childView, listViewCell) => {
             View.measureChild(this, childView, childView._currentWidthMeasureSpec, childView._currentHeightMeasureSpec);
         });
+        this._headerMap.forEach((childView, listViewHeaderCell) => {
+            View.measureChild(this, childView, childView._currentWidthMeasureSpec, childView._currentHeightMeasureSpec);
+        });
     }
     onLayout(left, top, right, bottom) {
         super.onLayout(left, top, right, bottom);
@@ -355,6 +511,12 @@ export class ListView extends ListViewBase {
                 View.layoutChild(this, childView, 0, 0, width, cellHeight);
             }
         });
+        this._headerMap.forEach((childView, listViewHeaderCell) => {
+            const headerHeight = this.stickyHeaderHeight === 'auto' ? 44 : Length.toDevicePixels(this.stickyHeaderHeight, 44);
+            const width = layout.getMeasureSpecSize(this.widthMeasureSpec);
+            childView.iosOverflowSafeAreaEnabled = false;
+            View.layoutChild(this, childView, 0, 0, width, headerHeight);
+        });
     }
     _layoutCell(cellView, indexPath) {
         if (cellView) {
@@ -373,10 +535,21 @@ export class ListView extends ListViewBase {
             this._preparingCell = true;
             let view = cell.view;
             if (!view) {
-                view = this._getItemTemplate(indexPath.row).createView();
+                if (this.sectioned) {
+                    // For sectioned data, we need to calculate the absolute index for template selection
+                    let absoluteIndex = 0;
+                    for (let i = 0; i < indexPath.section; i++) {
+                        absoluteIndex += this._getItemsInSection(i).length;
+                    }
+                    absoluteIndex += indexPath.row;
+                    view = this._getItemTemplate(absoluteIndex).createView();
+                }
+                else {
+                    view = this._getItemTemplate(indexPath.row).createView();
+                }
             }
             const args = notifyForItemAtIndex(this, cell, view, ITEMLOADING, indexPath);
-            view = args.view || this._getDefaultItemContent(indexPath.row);
+            view = args.view || this._getDefaultItemContent(this.sectioned ? indexPath.row : indexPath.row);
             // Proxy containers should not get treated as layouts.
             // Wrap them in a real layout as well.
             if (view instanceof ProxyViewContainer) {
@@ -394,8 +567,15 @@ export class ListView extends ListViewBase {
                 this._removeContainer(cell);
                 cell.owner = new WeakRef(view);
             }
-            this._prepareItem(view, indexPath.row);
-            view._listViewItemIndex = indexPath.row;
+            if (this.sectioned) {
+                this._prepareItemInSection(view, indexPath.section, indexPath.row);
+                view._listViewItemIndex = indexPath.row; // Keep row index for compatibility
+                view._listViewSectionIndex = indexPath.section;
+            }
+            else {
+                this._prepareItem(view, indexPath.row);
+                view._listViewItemIndex = indexPath.row;
+            }
             this._map.set(cell, view);
             // We expect that views returned from itemLoading are new (e.g. not reused).
             if (view && !view.parent) {
@@ -423,6 +603,151 @@ export class ListView extends ListViewBase {
         this._preparingCell = preparing;
         this._map.delete(cell);
     }
+    _prepareHeader(headerCell, section) {
+        let headerHeight;
+        try {
+            this._preparingHeader = true;
+            let view = headerCell.view;
+            if (!view) {
+                view = this._getHeaderTemplate();
+                if (!view) {
+                    if (Trace.isEnabled()) {
+                        Trace.write(`ListView: Failed to create header view for section ${section}`, Trace.categories.Debug);
+                    }
+                    // Create a fallback view
+                    const lbl = new Label();
+                    lbl.text = `Section ${section}`;
+                    view = lbl;
+                }
+            }
+            // Handle header cell reuse
+            if (!headerCell.view) {
+                headerCell.owner = new WeakRef(view);
+            }
+            else if (headerCell.view !== view) {
+                // Remove old view and set new one
+                headerCell.view.nativeViewProtected?.removeFromSuperview();
+                this._removeHeaderContainer(headerCell);
+                headerCell.owner = new WeakRef(view);
+            }
+            // Clear existing binding context and set new one
+            if (view.bindingContext) {
+                view.bindingContext = null;
+            }
+            if (this.sectioned) {
+                const sectionData = this._getSectionData(section);
+                if (sectionData) {
+                    view.bindingContext = sectionData;
+                }
+                else {
+                    // Fallback if section data is missing
+                    view.bindingContext = { title: `Section ${section}`, section: section };
+                }
+            }
+            else {
+                view.bindingContext = this.bindingContext;
+            }
+            // Force immediate binding context evaluation
+            if (view && typeof view._onBindingContextChanged === 'function') {
+                view._onBindingContextChanged(null, view.bindingContext);
+                // Also trigger for child views
+                // @ts-ignore
+                if (view._childrenCount) {
+                    view.eachChildView((child) => {
+                        if (typeof child._onBindingContextChanged === 'function') {
+                            child._onBindingContextChanged(null, view.bindingContext);
+                        }
+                        return true;
+                    });
+                }
+            }
+            this._headerMap.set(headerCell, view);
+            // Add new header view to the cell
+            if (view && !view.parent) {
+                this._addView(view);
+                headerCell.contentView.addSubview(view.nativeViewProtected);
+            }
+            // Request layout and measure/layout the header
+            if (view && view.bindingContext) {
+                view.requestLayout();
+            }
+            headerHeight = this._layoutHeader(view);
+        }
+        finally {
+            this._preparingHeader = false;
+        }
+        return headerHeight;
+    }
+    _layoutHeader(headerView) {
+        if (headerView) {
+            const headerHeight = this.stickyHeaderHeight === 'auto' ? 44 : Length.toDevicePixels(this.stickyHeaderHeight, 44);
+            const heightMeasureSpec = layout.makeMeasureSpec(headerHeight, layout.EXACTLY);
+            const measuredSize = View.measureChild(this, headerView, this.widthMeasureSpec, heightMeasureSpec);
+            // Layout the header with the measured size
+            View.layoutChild(this, headerView, 0, 0, measuredSize.measuredWidth, measuredSize.measuredHeight);
+            return measuredSize.measuredHeight;
+        }
+        return 44;
+    }
+    _getHeaderTemplate() {
+        if (this.stickyHeaderTemplate) {
+            if (__UI_USE_EXTERNAL_RENDERER__) {
+                if (isFunction(this.stickyHeaderTemplate)) {
+                    return this.stickyHeaderTemplate();
+                }
+            }
+            else {
+                if (typeof this.stickyHeaderTemplate === 'string') {
+                    try {
+                        const parsed = Builder.parse(this.stickyHeaderTemplate, this);
+                        if (!parsed) {
+                            // Create a simple fallback
+                            const fallbackLabel = new Label();
+                            fallbackLabel.text = 'Parse Failed';
+                            return fallbackLabel;
+                        }
+                        return parsed;
+                    }
+                    catch (error) {
+                        if (Trace.isEnabled()) {
+                            Trace.write(`ListView: Template parsing error: ${error}`, Trace.categories.Debug);
+                        }
+                        // Create a simple fallback
+                        const errorLabel = new Label();
+                        errorLabel.text = 'Template Error';
+                        return errorLabel;
+                    }
+                }
+                else {
+                    const view = this.stickyHeaderTemplate();
+                    if (Trace.isEnabled()) {
+                        Trace.write(`ListView: Created header view from template function: ${!!view} (type: ${view?.constructor?.name})`, Trace.categories.Debug);
+                    }
+                    return view;
+                }
+            }
+        }
+        if (Trace.isEnabled()) {
+            Trace.write(`ListView: No sticky header template, creating default`, Trace.categories.Debug);
+        }
+        // Return a default header if no template is provided
+        const lbl = new Label();
+        lbl.text = 'Default Header';
+        return lbl;
+    }
+    _removeHeaderContainer(headerCell) {
+        const view = headerCell.view;
+        // This is to clear the StackLayout that is used to wrap ProxyViewContainer instances.
+        if (!(view.parent instanceof ListView)) {
+            this._removeView(view.parent);
+        }
+        // No need to request layout when we are removing headers.
+        const preparing = this._preparingHeader;
+        this._preparingHeader = true;
+        view.parent._removeView(view);
+        this._preparingHeader = preparing;
+        this._headerMap.delete(headerCell);
+    }
     [separatorColorProperty.getDefault]() {
         return this.nativeViewProtected.separatorColor;
     }
@@ -450,6 +775,56 @@ export class ListView extends ListViewBase {
         const estimatedHeight = layout.toDeviceIndependentPixels(Length.toDevicePixels(value, 0));
         nativeView.estimatedRowHeight = estimatedHeight < 0 ? DEFAULT_HEIGHT : estimatedHeight;
     }
+    [stickyHeaderProperty.getDefault]() {
+        return false;
+    }
+    [stickyHeaderProperty.setNative](value) {
+        if (Trace.isEnabled()) {
+            Trace.write(`ListView: stickyHeader set to ${value}`, Trace.categories.Debug);
+        }
+        // Immediately refresh to apply changes
+        if (this.isLoaded) {
+            this.refresh();
+        }
+    }
+    [stickyHeaderTemplateProperty.getDefault]() {
+        return null;
+    }
+    [stickyHeaderTemplateProperty.setNative](value) {
+        if (Trace.isEnabled()) {
+            Trace.write(`ListView: stickyHeaderTemplate set: ${typeof value} ${value ? '(has value)' : '(null)'}`, Trace.categories.Debug);
+        }
+        // Clear any cached template
+        this._headerTemplateCache = null;
+        // Immediately refresh to apply changes
+        if (this.isLoaded) {
+            this.refresh();
+        }
+    }
+    [stickyHeaderHeightProperty.getDefault]() {
+        return 'auto';
+    }
+    [stickyHeaderHeightProperty.setNative](value) {
+        if (Trace.isEnabled()) {
+            Trace.write(`ListView: stickyHeaderHeight set to ${value}`, Trace.categories.Debug);
+        }
+        // Immediately refresh to apply changes
+        if (this.isLoaded) {
+            this.refresh();
+        }
+    }
+    [sectionedProperty.getDefault]() {
+        return false;
+    }
+    [sectionedProperty.setNative](value) {
+        if (Trace.isEnabled()) {
+            Trace.write(`ListView: sectioned set to ${value}`, Trace.categories.Debug);
+        }
+        // Immediately refresh to apply changes
+        if (this.isLoaded) {
+            this.refresh();
+        }
+    }
 }
 __decorate([
     profile,